diff --git a/README.md b/README.md index 37259015..6a74dc89 100644 --- a/README.md +++ b/README.md @@ -100,7 +100,6 @@ variants close the gap: they recompile the same source with `ISequencer` mapped 13. [Migration guides](#systemreactive-to-reactiveuiprimitives-migration-guide) 14. [Benchmarks and performance posture](#benchmarks-and-performance-posture) 15. [Repository layout](#repository-layout) -16. [Validation commands](#validation-commands) ## Install @@ -127,10 +126,15 @@ integration point. Every package below ships at the same version and targets the | [ReactiveUI.Primitives.Extensions][Ext] | [![ExtB]][Ext] | The migrated non-async `ReactiveUI.Extensions` helper operators on lean Primitives. | | [ReactiveUI.Primitives.Extensions.Reactive][ExtRx] | [![ExtRxB]][ExtRx] | Migrated extension helpers compiled against System.Reactive `Unit` and `IScheduler`. | | [ReactiveUI.Primitives.Wpf][Wpf] | [![WpfB]][Wpf] | WPF dispatcher sequencer integration. | +| [ReactiveUI.Primitives.Wpf.Reactive][WpfRx] | [![WpfRxB]][WpfRx] | WPF dispatcher scheduler integration for System.Reactive-first projects. | | [ReactiveUI.Primitives.WinForms][WinForms] | [![WinFormsB]][WinForms] | Windows Forms control sequencer integration. | +| [ReactiveUI.Primitives.WinForms.Reactive][WinFormsRx] | [![WinFormsRxB]][WinFormsRx] | Windows Forms control scheduler integration for System.Reactive-first projects. | | [ReactiveUI.Primitives.WinUI][WinUI] | [![WinUIB]][WinUI] | WinUI dispatcher-queue sequencer integration. | +| [ReactiveUI.Primitives.WinUI.Reactive][WinUIRx] | [![WinUIRxB]][WinUIRx] | WinUI dispatcher-queue scheduler integration for System.Reactive-first projects. | | [ReactiveUI.Primitives.Blazor][Blazor] | [![BlazorB]][Blazor] | Blazor renderer sequencer integration. | +| [ReactiveUI.Primitives.Blazor.Reactive][BlazorRx] | [![BlazorRxB]][BlazorRx] | Blazor renderer scheduler integration for System.Reactive-first projects. | | [ReactiveUI.Primitives.Maui][Maui] | [![MauiB]][Maui] | MAUI dispatcher sequencer integration. | +| [ReactiveUI.Primitives.Maui.Reactive][MauiRx] | [![MauiRxB]][MauiRx] | MAUI dispatcher scheduler integration for System.Reactive-first projects. | [Disp]: https://www.nuget.org/packages/ReactiveUI.Disposables/ [DispB]: https://img.shields.io/nuget/v/ReactiveUI.Disposables.svg @@ -154,14 +158,24 @@ integration point. Every package below ships at the same version and targets the [ExtRxB]: https://img.shields.io/nuget/v/ReactiveUI.Primitives.Extensions.Reactive.svg [Wpf]: https://www.nuget.org/packages/ReactiveUI.Primitives.Wpf/ [WpfB]: https://img.shields.io/nuget/v/ReactiveUI.Primitives.Wpf.svg +[WpfRx]: https://www.nuget.org/packages/ReactiveUI.Primitives.Wpf.Reactive/ +[WpfRxB]: https://img.shields.io/nuget/v/ReactiveUI.Primitives.Wpf.Reactive.svg [WinForms]: https://www.nuget.org/packages/ReactiveUI.Primitives.WinForms/ [WinFormsB]: https://img.shields.io/nuget/v/ReactiveUI.Primitives.WinForms.svg +[WinFormsRx]: https://www.nuget.org/packages/ReactiveUI.Primitives.WinForms.Reactive/ +[WinFormsRxB]: https://img.shields.io/nuget/v/ReactiveUI.Primitives.WinForms.Reactive.svg [WinUI]: https://www.nuget.org/packages/ReactiveUI.Primitives.WinUI/ [WinUIB]: https://img.shields.io/nuget/v/ReactiveUI.Primitives.WinUI.svg +[WinUIRx]: https://www.nuget.org/packages/ReactiveUI.Primitives.WinUI.Reactive/ +[WinUIRxB]: https://img.shields.io/nuget/v/ReactiveUI.Primitives.WinUI.Reactive.svg [Blazor]: https://www.nuget.org/packages/ReactiveUI.Primitives.Blazor/ [BlazorB]: https://img.shields.io/nuget/v/ReactiveUI.Primitives.Blazor.svg +[BlazorRx]: https://www.nuget.org/packages/ReactiveUI.Primitives.Blazor.Reactive/ +[BlazorRxB]: https://img.shields.io/nuget/v/ReactiveUI.Primitives.Blazor.Reactive.svg [Maui]: https://www.nuget.org/packages/ReactiveUI.Primitives.Maui/ [MauiB]: https://img.shields.io/nuget/v/ReactiveUI.Primitives.Maui.svg +[MauiRx]: https://www.nuget.org/packages/ReactiveUI.Primitives.Maui.Reactive/ +[MauiRxB]: https://img.shields.io/nuget/v/ReactiveUI.Primitives.Maui.Reactive.svg ### How the packages layer @@ -169,7 +183,7 @@ Each family (base, async, extensions) follows the same shape: a type-agnostic `. **lean** leaf binds the abstract `RxVoid`/`ISequencer` types to its own lightweight implementations, while the `.Reactive` leaf recompiles the same source against System.Reactive's `Unit`/`IScheduler`. Pick the lean leaf for a dependency-free build, or the `.Reactive` leaf to interoperate with an existing System.Reactive codebase. The platform -packages build on the lean base. (Arrows point from a package to what it depends on.) +packages also come in lean and `.Reactive` leaves. (Arrows point from a package to what it depends on.) ```mermaid graph TD @@ -185,6 +199,7 @@ graph TD Ext["...Extensions (lean)"] ExtRx["...Extensions.Reactive"] Plat["Wpf / WinForms / WinUI
Blazor / Maui"] + PlatRx["Wpf.Reactive / WinForms.Reactive
WinUI.Reactive / Blazor.Reactive / Maui.Reactive"] Core --> Disp Prim --> Core @@ -202,6 +217,7 @@ graph TD ExtRx --> Rx ExtRx --> ExtCore Plat --> Prim + PlatRx --> Rx ``` @@ -287,14 +303,17 @@ Package TFM groups are: - `ReactiveUI.Primitives`: `$(LibraryTargetFrameworks)` plus `net10.0-android`, `net11.0-android`, and Apple platform TFMs (`net10.0-ios`, `net11.0-ios`, `net10.0-tvos`, `net11.0-tvos`, `net10.0-macos`, `net11.0-macos`, `net10.0-maccatalyst`, `net11.0-maccatalyst`) when the build OS supports restoring those workloads. -- `ReactiveUI.Primitives.Wpf`: `net8.0-windows`, `net9.0-windows`, `net10.0-windows`, `net11.0-windows`, `net462`, - `net472`, `net48`, `net481`. -- `ReactiveUI.Primitives.WinForms`: `net8.0-windows`, `net9.0-windows`, `net10.0-windows`, `net11.0-windows`, `net462`, - `net472`, `net48`, `net481`. -- `ReactiveUI.Primitives.WinUI`: `net8.0-windows10.0.19041.0`, `net9.0-windows10.0.19041.0`, - `net10.0-windows10.0.19041.0`, `net11.0-windows10.0.19041.0`. -- `ReactiveUI.Primitives.Blazor`: `net8.0`, `net9.0`, `net10.0`, `net11.0`. -- `ReactiveUI.Primitives.Maui`: `net9.0`, `net10.0`, `net11.0`. +- `ReactiveUI.Primitives.Reactive`: the same matrix as `ReactiveUI.Primitives`, compiled with System.Reactive `Unit` and + `IScheduler` aliases. +- `ReactiveUI.Primitives.Wpf` and `ReactiveUI.Primitives.Wpf.Reactive`: `net8.0-windows`, `net9.0-windows`, + `net10.0-windows`, `net11.0-windows`, `net462`, `net472`, `net48`, `net481`. +- `ReactiveUI.Primitives.WinForms` and `ReactiveUI.Primitives.WinForms.Reactive`: `net8.0-windows`, + `net9.0-windows`, `net10.0-windows`, `net11.0-windows`, `net462`, `net472`, `net48`, `net481`. +- `ReactiveUI.Primitives.WinUI` and `ReactiveUI.Primitives.WinUI.Reactive`: `net8.0-windows10.0.19041.0`, + `net9.0-windows10.0.19041.0`, `net10.0-windows10.0.19041.0`, `net11.0-windows10.0.19041.0`. +- `ReactiveUI.Primitives.Blazor` and `ReactiveUI.Primitives.Blazor.Reactive`: `net8.0`, `net9.0`, `net10.0`, + `net11.0`. +- `ReactiveUI.Primitives.Maui` and `ReactiveUI.Primitives.Maui.Reactive`: `net9.0`, `net10.0`, `net11.0`. Runtime package dependencies are intentionally small. The default production packages do not depend on System.Reactive, R3, or R3Async. `ReactiveUI.Primitives` references `ReactiveUI.Disposables`, `ReactiveUI.Primitives.Core`, and the @@ -314,9 +333,10 @@ System.ComponentModel.Annotations, System.Buffers, System.Memory, and System.Col package also embeds `ReactiveUI.Primitives.R3Bridge.Generator.dll` so R3/R3Async bridge methods can be generated in consuming projects that already reference those external libraries. -`ReactiveUI.Primitives.Blazor` references `Microsoft.AspNetCore.Components`, `ReactiveUI.Primitives.Maui` references -`Microsoft.Maui.Core` and Microsoft.Extensions infrastructure packages, and `ReactiveUI.Primitives.WinUI` references -`Microsoft.WindowsAppSDK`. The remaining shared package references are analyzer, SourceLink, versioning, ILLink, +`ReactiveUI.Primitives.Blazor` and `ReactiveUI.Primitives.Blazor.Reactive` reference `Microsoft.AspNetCore.Components`. +`ReactiveUI.Primitives.Maui` and `ReactiveUI.Primitives.Maui.Reactive` reference `Microsoft.Maui.Core` and +Microsoft.Extensions infrastructure packages. `ReactiveUI.Primitives.WinUI` and `ReactiveUI.Primitives.WinUI.Reactive` +reference `Microsoft.WindowsAppSDK`. The remaining shared package references are analyzer, SourceLink, versioning, ILLink, reference-assembly, or build-time support packages such as Blazor.Common.Analyzers, Microsoft.SourceLink.GitHub, MinVer, Roslynator.Analyzers, SonarAnalyzer.CSharp, StyleSharp.Analyzers, Microsoft.NET.ILLink.Tasks, and Microsoft.NETFramework.ReferenceAssemblies. Benchmark projects may reference System.Reactive, @@ -584,6 +604,7 @@ using var subscription = labels.Subscribe(Console.WriteLine); | filter-null + project + switch to latest inner | `SwitchSelect` | | pairwise zip | `Pair` | | latest-value combination | `SyncLatest` | +| System.Reactive-named latest combination | `CombineLatest` | | combine left emission with latest right value | `Latch` | | latest-fusion alias | `PairLatest`, `FuseLatest` | | last values after both complete | `ForkJoin` | @@ -620,6 +641,31 @@ width.Value = 800; height.Value = 600; ``` +`SyncLatest` and the System.Reactive-named `CombineLatest` overloads support multi-source projections up to 16 total +sources. The `.Reactive` package variants expose the same overloads with `System.Reactive.Unit` and `IScheduler` +conventions, which keeps migrated Rx code using familiar `CombineLatest` names while running on the Primitives +implementation. + +Multi-source latest example: + +```csharp +using ReactiveUI.Primitives; +using ReactiveUI.Primitives.Signals; + +var first = new StateSignal(1); +var second = new StateSignal(2); +var third = new StateSignal(3); + +using var total = first + .SyncLatest(second, third, static (a, b, c) => a + b + c) + .Subscribe(value => Console.WriteLine($"total={value}")); + +third.Value = 10; +``` + +The Rx-name `SelectMany` observable overloads keep concurrent merge semantics. Use `FlatMap` or `Bind` when you want the +Primitives name, and use `SelectMany` when porting existing Rx code or keeping LINQ query syntax. + Fused projection example (`Choose` and `SwitchSelect`): ```csharp @@ -863,6 +909,9 @@ using IDisposable subscription = names.Subscribe(Console.WriteLine); The Extensions project is intended for applications that already use the helper operators from `ReactiveUI.Extensions` and want the same shapes without pulling System.Reactive or R3 into the production dependency graph. +`Filter(string pattern)` creates a regex with a 30-second match timeout so ordinary filters remain stable under +instrumented CI runs while still protecting against runaway patterns. Use `Filter(Regex regex)` when a caller-specified +regex timeout or options set must be preserved exactly. ## Stateful signals and subject-like types @@ -1100,6 +1149,101 @@ When a project must keep System.Reactive `Unit` or `IScheduler` in its public su `ReactiveUI.Primitives.Extensions.Reactive`. When the goal is to migrate away from those public System.Reactive types, use the lean packages and the mappings below. +### Migration track: existing `xyz` project + +Use this track when the project should eventually stop exposing System.Reactive types and use the lean +ReactiveUI.Primitives package family. + +1. Inventory references and public API. Mark each project that exposes `System.Reactive.Unit`, `IScheduler`, + `IObservable` extension methods, UI schedulers, `Subject` types, or ReactiveUI.Extensions helpers. +2. Add the lean packages needed by the existing project: + +```bash +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.Extensions +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.Async +``` + +3. Add only the matching UI integration package when the project owns UI-thread dispatch: + +```bash +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.Wpf +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.WinForms +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.WinUI +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.Blazor +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.Maui +``` + +4. Convert boundary types deliberately: `System.Reactive.Unit` to `RxVoid`, `IScheduler` to `ISequencer`, Rx subjects to + `Signal`, `StateSignal`, `ReplaySignal`, or `FinalSignal`, and composite disposable types to + `MultipleDisposable`, `Pocket`, `Slot`, or `AssignmentSlot`. +5. Keep code compiling during the first pass by using the Rx-name compatibility layer (`Select`, `Where`, `Aggregate`, + `Scan`, `Merge`, `Concat`, `CombineLatest`, `SelectMany`, and related aliases). Then move hot paths to Primitives + names (`Map`, `Keep`, `Reduce`, `Fold`, `Blend`, `Chain`, `SyncLatest`, `FlatMap`) where that makes the code clearer. +6. Replace scheduler construction and tests: use `Sequencer.Immediate`, `Sequencer.CurrentThread`, + `ThreadPoolSequencer.Instance`, `TaskPoolSequencer.Instance`, UI sequencers, and `VirtualClock`. +7. Remove `System.Reactive` and `ReactiveUI.Extensions` package references only after the project builds without + `System.Reactive.Linq`, `System.Reactive.Subjects`, `System.Reactive.Disposables`, or + `System.Reactive.Concurrency` imports. +8. Run tests and package/API approval checks. For time-sensitive tests, use virtual time rather than real sleeps. + +### Migration track: new `xyz.Reactive` project + +Use this track when an existing Rx-based source base must remain source-compatible for consumers while the repository +moves implementation work onto ReactiveUI.Primitives. The pattern is to keep or create a `xyz` lean package and add a +new `xyz.Reactive` package that references the `.Reactive` Primitives range. + +1. Move shared implementation files into a shared source folder that can be linked by both projects. +2. In shared source, use the neutral identifiers `RxVoid` and `ISequencer`. In the lean project they bind to + ReactiveUI.Primitives types; in the `.Reactive` project they bind to `System.Reactive.Unit` and + `System.Reactive.Concurrency.IScheduler`. +3. Gate namespaces when the public namespace must differ: + +```csharp +#if REACTIVE_SHIM +namespace xyz.Reactive; +#else +namespace xyz; +#endif +``` + +4. Reference the `.Reactive` packages from `xyz.Reactive`: + +```bash +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.Reactive +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.Extensions.Reactive +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.Async.Reactive +``` + +5. Add the matching reactive UI package only when the project exposes UI scheduling: + +```bash +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.Wpf.Reactive +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.WinForms.Reactive +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.WinUI.Reactive +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.Blazor.Reactive +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.Maui.Reactive +``` + +6. Configure the reactive project to define `REACTIVE_SHIM` and alias the System.Reactive types if your repository does + not already centralize this in `Directory.Build.props`: + +```xml + + $(DefineConstants);REACTIVE_SHIM + + + + + +``` + +7. Prefer zero source changes in the first `xyz.Reactive` pass: keep Rx names such as `Select`, `Where`, `SelectMany`, + `CombineLatest`, `Merge`, `Concat`, `Throttle`, and `WithLatestFrom` where compatibility matters. The `.Reactive` + Primitives packages supply those names over the Primitives implementation. +8. Build both packages side by side. `xyz` should have no System.Reactive runtime dependency; `xyz.Reactive` should keep + System.Reactive-facing APIs for existing consumers. + ### Factory mapping | System.Reactive | ReactiveUI.Primitives | Notes | @@ -1139,7 +1283,7 @@ use the lean packages and the mappings below. |----------------------------------|--------------------------------------------------------|-----------------------------------------------------------------------------------------------------| | `Select` | `Map` | Prefer `Map` for distinct Primitives style. | | `Where` | `Keep` | Predicate filtering. | -| `SelectMany` | `FlatMap` or `Bind` | `Bind` is a Primitives alias for flat mapping. | +| `SelectMany` | `FlatMap`, `Bind`, or Rx-name `SelectMany` | Observable overloads preserve concurrent merge semantics; enumerable overloads flatten inline. | | `Aggregate` | `Reduce` | Emits final accumulated value on completion. | | `Scan` | `Fold` | Emits every accumulated value. | | `Do` | `Tap` | Side effect while preserving values. | @@ -1158,7 +1302,7 @@ use the lean packages and the mappings below. | `Switch` | `SwitchTo` | Latest inner observable wins. | | `Select` + `Switch` | `SwitchSelect` | Filters null source values, projects each to an inner observable, and mirrors only the latest. | | `Zip` | `Pair` or `Signal.Pair` | Pair values by index. | -| `CombineLatest` | `SyncLatest` or `Signal.SyncLatest` | Latest values after both sources have emitted. | +| `CombineLatest` | `SyncLatest`, Rx-name `CombineLatest`, or `Signal.SyncLatest` | Latest values after all sources have emitted; overloads support up to 16 total sources. | | `WithLatestFrom` | `Latch` | Left emission paired with latest right value. | | `ForkJoin` | `ForkJoin` | Last values after completion. | | `Throttle` | `Calm` / `Stabilize` | Quiet-period emission. | @@ -1575,10 +1719,15 @@ duration is indistinguishable from empty method overhead; the benchmark run stil | `src/ReactiveUI.Primitives.Extensions` | Migrated non-async ReactiveUI.Extensions helper operators backed by lean Primitives. | | `src/ReactiveUI.Primitives.Extensions.Reactive` | System.Reactive-flavoured Extensions helper leaf. | | `src/ReactiveUI.Primitives.Wpf` | Optional WPF dispatcher integration library. | +| `src/ReactiveUI.Primitives.Wpf.Reactive` | Optional WPF dispatcher scheduler integration library for System.Reactive consumers. | | `src/ReactiveUI.Primitives.WinForms` | Optional Windows Forms control integration library. | +| `src/ReactiveUI.Primitives.WinForms.Reactive` | Optional Windows Forms control scheduler integration library for System.Reactive consumers. | | `src/ReactiveUI.Primitives.WinUI` | Optional WinUI dispatcher queue integration library. | +| `src/ReactiveUI.Primitives.WinUI.Reactive` | Optional WinUI dispatcher queue scheduler integration library for System.Reactive consumers. | | `src/ReactiveUI.Primitives.Blazor` | Optional Blazor renderer integration library. | +| `src/ReactiveUI.Primitives.Blazor.Reactive` | Optional Blazor renderer scheduler integration library for System.Reactive consumers. | | `src/ReactiveUI.Primitives.Maui` | Optional MAUI dispatcher integration library. | +| `src/ReactiveUI.Primitives.Maui.Reactive` | Optional MAUI dispatcher scheduler integration library for System.Reactive consumers. | | `src/ReactiveUI.Primitives.R3Bridge.Generator` | Non-packable analyzer project embedded by the lean base and async packages for R3 bridges. | | `src/Primitives.Shared` | Linked lean/Reactive synchronous source. | | `src/Primitives.Async.Shared` | Linked lean/Reactive async source. | diff --git a/Skill.md b/Skill.md index 57408aa7..16ab7c4f 100644 --- a/Skill.md +++ b/Skill.md @@ -1,6 +1,6 @@ --- name: reactiveui-primitives -description: Use when working with ReactiveUI.Primitives NuGet packages in .NET projects, including ReactiveUI.Disposables, ReactiveUI.Primitives.Core, ReactiveUI.Primitives, ReactiveUI.Primitives.Reactive, ReactiveUI.Primitives.Async.Core, ReactiveUI.Primitives.Async, ReactiveUI.Primitives.Async.Reactive, ReactiveUI.Primitives.Extensions.Core, ReactiveUI.Primitives.Extensions, ReactiveUI.Primitives.Extensions.Reactive, ReactiveUI.Primitives.Wpf, ReactiveUI.Primitives.WinForms, ReactiveUI.Primitives.WinUI, ReactiveUI.Primitives.Blazor, or ReactiveUI.Primitives.Maui; choosing Core vs lean vs System.Reactive package variants; using IObservable, IObservableAsync, signals, sequencers, disposable helpers, UI dispatch adapters, R3/R3Async generated bridges, or migration guidance from System.Reactive/R3. +description: Use when working with ReactiveUI.Primitives NuGet packages in .NET projects, including ReactiveUI.Disposables, ReactiveUI.Primitives.Core, ReactiveUI.Primitives, ReactiveUI.Primitives.Reactive, ReactiveUI.Primitives.Async.Core, ReactiveUI.Primitives.Async, ReactiveUI.Primitives.Async.Reactive, ReactiveUI.Primitives.Extensions.Core, ReactiveUI.Primitives.Extensions, ReactiveUI.Primitives.Extensions.Reactive, ReactiveUI.Primitives.Wpf, ReactiveUI.Primitives.Wpf.Reactive, ReactiveUI.Primitives.WinForms, ReactiveUI.Primitives.WinForms.Reactive, ReactiveUI.Primitives.WinUI, ReactiveUI.Primitives.WinUI.Reactive, ReactiveUI.Primitives.Blazor, ReactiveUI.Primitives.Blazor.Reactive, ReactiveUI.Primitives.Maui, or ReactiveUI.Primitives.Maui.Reactive; choosing Core vs lean vs System.Reactive package variants; using IObservable, IObservableAsync, signals, sequencers, disposable helpers, UI dispatch adapters, R3/R3Async generated bridges, or migration guidance from System.Reactive/R3/R3Async repositories to Primitives or .Reactive package variants. --- # ReactiveUI.Primitives @@ -24,10 +24,15 @@ Default to the non-Core leaf packages for applications. Choose Core packages onl | `ReactiveUI.Primitives.Extensions` | The app needs convenience operators over lean BCL `IObservable` pipelines. | `ReactiveUI.Primitives.Extensions`; `ReactiveExtensions`, `ObservableSubscriptionExtensions`, buffering, debounce/throttle, stale detection, retry/backoff, heartbeat, observe-on helpers, pairwise/partition, `ToHotTask`, `ToHotValueTask`, `SubscribeAsync`, `WaitUntil`, `AsSignal`. Depends on `ReactiveUI.Primitives` and `ReactiveUI.Primitives.Extensions.Core`. | | `ReactiveUI.Primitives.Extensions.Reactive` | The app needs the Extensions surface in System.Reactive-first code. | Same extension family as `ReactiveUI.Primitives.Extensions`, recompiled under `.Reactive` namespaces and `System.Reactive` scheduler/unit conventions. Depends on `ReactiveUI.Primitives.Reactive` and `ReactiveUI.Primitives.Extensions.Core`. | | `ReactiveUI.Primitives.Wpf` | WPF UI code needs dispatcher marshalling. | `ReactiveUI.Primitives.Concurrency.DispatcherSequencer`. Depends on `ReactiveUI.Primitives`. | +| `ReactiveUI.Primitives.Wpf.Reactive` | WPF UI code is System.Reactive-first and needs dispatcher scheduling. | `ReactiveUI.Primitives.Reactive.Concurrency.DispatcherSequencer` implements System.Reactive scheduling conventions. Depends on `ReactiveUI.Primitives.Reactive`. | | `ReactiveUI.Primitives.WinForms` | Windows Forms UI code needs control-thread marshalling. | `ReactiveUI.Primitives.Concurrency.ControlSequencer`. Depends on `ReactiveUI.Primitives`. | +| `ReactiveUI.Primitives.WinForms.Reactive` | Windows Forms UI code is System.Reactive-first and needs control-thread scheduling. | `ReactiveUI.Primitives.Reactive.Concurrency.ControlSequencer`. Depends on `ReactiveUI.Primitives.Reactive`. | | `ReactiveUI.Primitives.WinUI` | WinUI code needs `DispatcherQueue` marshalling. | `ReactiveUI.Primitives.Concurrency.DispatcherQueueSequencer` and `DispatcherQueueSequencerExtensions.ToSequencer()`. Depends on `ReactiveUI.Primitives` and `Microsoft.WindowsAppSDK`. | +| `ReactiveUI.Primitives.WinUI.Reactive` | WinUI code is System.Reactive-first and needs `DispatcherQueue` scheduling. | `ReactiveUI.Primitives.Reactive.Concurrency.DispatcherQueueSequencer` and `DispatcherQueueSequencerExtensions.ToSequencer()`. Depends on `ReactiveUI.Primitives.Reactive` and `Microsoft.WindowsAppSDK`. | | `ReactiveUI.Primitives.Blazor` | Blazor components need render-thread sequencing and component-bound subscriptions. | `ReactiveUI.Primitives.Blazor.Components.ReactiveComponentBase`, `Observe`, `Track`, `InvalidateAsync`, `ReactiveUI.Primitives.Blazor.Concurrency.BlazorRendererSequencer`. Depends on `ReactiveUI.Primitives` and `Microsoft.AspNetCore.Components`. | +| `ReactiveUI.Primitives.Blazor.Reactive` | Blazor components are System.Reactive-first and need render-thread scheduling. | `ReactiveUI.Primitives.Blazor.Reactive.Components.ReactiveComponentBase` and `ReactiveUI.Primitives.Blazor.Reactive.Concurrency.BlazorRendererSequencer`. Depends on `ReactiveUI.Primitives.Reactive` and `Microsoft.AspNetCore.Components`. | | `ReactiveUI.Primitives.Maui` | .NET MAUI code needs dispatcher marshalling. | `ReactiveUI.Primitives.Concurrency.MauiDispatcherSequencer` and `MauiDispatcherSequencerExtensions.ToSequencer()`. Depends on `ReactiveUI.Primitives` and `Microsoft.Maui.Core`. | +| `ReactiveUI.Primitives.Maui.Reactive` | .NET MAUI code is System.Reactive-first and needs dispatcher scheduling. | `ReactiveUI.Primitives.Reactive.Concurrency.MauiDispatcherSequencer` and `MauiDispatcherSequencerExtensions.ToSequencer()`. Depends on `ReactiveUI.Primitives.Reactive` and `Microsoft.Maui.Core`. | Install examples: @@ -52,6 +57,7 @@ Use `.Reactive` packages when the project already uses System.Reactive idioms: dotnet add package ReactiveUI.Primitives.Reactive dotnet add package ReactiveUI.Primitives.Async.Reactive dotnet add package ReactiveUI.Primitives.Extensions.Reactive +dotnet add package ReactiveUI.Primitives.Wpf.Reactive ``` Do not add `ReactiveUI.Primitives.R3Bridge.Generator` as a package. It is a non-packable Roslyn component whose output is packed as an analyzer by `ReactiveUI.Primitives` and `ReactiveUI.Primitives.Async`. @@ -61,8 +67,8 @@ Do not add `ReactiveUI.Primitives.R3Bridge.Generator` as a package. It is a non- - Prefer `ReactiveUI.Primitives` for new app code that uses BCL `IObservable`. - Prefer `ReactiveUI.Primitives.Async` when subscription, notification, or completion work must be asynchronous. - Prefer `ReactiveUI.Primitives.Extensions` for migrated helper operators from ReactiveUI.Extensions-style code. -- Prefer UI packages only in the matching UI framework. -- Prefer `.Reactive` variants only when public APIs should expose `System.Reactive.Unit`, `IScheduler`, or `.Reactive` namespaces. +- Prefer UI packages only in the matching UI framework; use the lean UI package for `ISequencer` and the `.Reactive` UI package for `IScheduler`. +- Prefer `.Reactive` variants when public APIs should expose `System.Reactive.Unit`, `IScheduler`, `.Reactive` namespaces, or existing Rx source should compile with minimal code changes. - Prefer `.Core` variants only when composing packages or minimizing a library dependency layer. Most apps should reference the leaf package. - Avoid mixing lean and `.Reactive` variants in the same pipeline without an explicit boundary; their namespaces and scheduler/unit conventions differ. - Do not add `System.Reactive` just to use core Primitives. The `.Reactive` packages add it for System.Reactive-first projects. @@ -105,6 +111,8 @@ using ReactiveUI.Primitives.Reactive.Signals; using ReactiveUI.Primitives.Extensions.Reactive; ``` +Reactive UI packages mostly expose sequencers under `ReactiveUI.Primitives.Reactive.Concurrency`. Blazor also exposes component helpers under `ReactiveUI.Primitives.Blazor.Reactive.Components`. + R3 generated bridges: ```csharp @@ -118,11 +126,95 @@ Use these landmarks to choose APIs quickly; rely on IntelliSense/PublicAPI for e - Signals and factories: `Signal`, `Signal`, `BehaviorSignal`, `StateSignal`, `ReplaySignal`, `ScheduledSignal`, `PrioritySemaphoreSignal`, `AnonymousSignal`, `ConnectableSignal`. - State and commands: `ReadOnlyState`, `CommandSignal`, `CommandExecution`, `TaskSignal`, `TaskSignal`. - Sequencing: `ISequencer`, `CurrentThreadSequencer`, `ImmediateSequencer`, `SynchronizationContextSequencer`, `TaskPoolSequencer`, `ThreadPoolSequencer`, `VirtualTimeSequencer`, `VirtualClock`. -- Operators: `Map`, `FlatMap`, `SelectMany`, `Where`, `Keep`, `KeepNotNull`, `Cast`, `Concat`, `Merge`, `Amb`, `Race`, `Switch`, `Retry`, `Recover`, `Rescue`, `Distinct`, `Take`, `Skip`, `Collect`, `Materialize`, `Dematerialize`, `ForkJoin`, `Pair`, `Latch`, `Synchronize`, `Timeout`, `Shift`, `Spark`, `Unspark`. +- Operators: `Map`, `FlatMap`, `Bind`, `SelectMany`, `Where`, `Keep`, `KeepNotNull`, `Cast`, `Concat`, `Merge`, `Amb`, `Race`, `Switch`, `Retry`, `Recover`, `Rescue`, `Distinct`, `Take`, `Skip`, `Collect`, `Materialize`, `Dematerialize`, `ForkJoin`, `Pair`, `Latch`, `SyncLatest`, `CombineLatest`, `Synchronize`, `Timeout`, `Shift`, `Spark`, `Unspark`. `SyncLatest` and Rx-name `CombineLatest` support up to 16 total sources; Rx-name `SelectMany` observable overloads preserve concurrent merge semantics. - Connectable helpers: `Replay`, `ReplayLive`, `Share`, `ShareLatest`, `AutoConnect`, `AutoShare`. - Async core: `IObservableAsync`, `IObserverAsync`, `SignalAsync`, `SignalAsync`, `WitnessAsync`, `ConnectableSignalAsync`, `ConcurrentWitnessCallsException`. - Async factories/operators: `SignalAsync.Create`, `Return`, `Range`, `FromAsync`, `FromAsyncEnumerable`, `Every`, `Interval`, `Timer`, `Using`, `Blend`, `Chain`, `Map`, `Merge`, `CombineLatest`, `Switch`, `ForEachAsync`, `Collect*Async`, `WaitCompletionAsync`, `OnErrorResumeAsFailure`. -- Extension helpers: `AsSignal`, `BufferUntil`, `BufferUntilIdle`, `DebounceImmediate`, `DebounceUntil`, `DetectStale`, `Heartbeat`, `ObserveOnSafe`, `ObserveOnIf`, `Pairwise`, `Partition`, `ReplayLastOnSubscribe`, `RetryWithBackoff`, `RetryWithDelay`, `RetryForeverWithDelay`, `RunAll`, `Shuffle`, `SwitchIfEmpty`, `Throttle*`, `ToHotTask`, `ToHotValueTask`, `WaitUntil`. +- Extension helpers: `AsSignal`, `BufferUntil`, `BufferUntilIdle`, `DebounceImmediate`, `DebounceUntil`, `DetectStale`, `Filter`, `Heartbeat`, `ObserveOnSafe`, `ObserveOnIf`, `Pairwise`, `Partition`, `ReplayLastOnSubscribe`, `RetryWithBackoff`, `RetryWithDelay`, `RetryForeverWithDelay`, `RunAll`, `Shuffle`, `SwitchIfEmpty`, `Throttle*`, `ToHotTask`, `ToHotValueTask`, `WaitUntil`. `Filter(string)` uses a 30-second regex timeout; `Filter(Regex)` preserves caller-supplied options and timeout. + +## Rx Migration Process + +Use this process when moving an Rx-based repository to ReactiveUI.Primitives. Decide first whether the immediate target is a lean Primitives project, a System.Reactive-compatible `.Reactive` project, or both. + +### Existing `xyz` Project To Lean Primitives + +Use this path when the existing project should stop exposing System.Reactive `Unit`, `IScheduler`, and package dependencies. + +1. Inventory package references and public APIs. Find `System.Reactive`, `System.Reactive.Linq`, `System.Reactive.Subjects`, `System.Reactive.Disposables`, `System.Reactive.Concurrency`, `ReactiveUI.Extensions`, `Unit`, `IScheduler`, `Subject`, `BehaviorSubject`, `ReplaySubject`, and `TestScheduler`. +2. Add the smallest lean package set: + +```bash +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.Extensions +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.Async +``` + +3. Add only the matching lean UI package when UI dispatch is used: + +```bash +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.Wpf +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.WinForms +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.WinUI +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.Blazor +dotnet add xyz/xyz.csproj package ReactiveUI.Primitives.Maui +``` + +4. Convert types at boundaries: `Unit` -> `RxVoid`, `IScheduler` -> `ISequencer`, `Subject` -> `Signal`, `BehaviorSubject` -> `StateSignal`, `ReplaySubject` -> `ReplaySignal`, `AsyncSubject` -> `FinalSignal`, `CompositeDisposable` -> `MultipleDisposable` or `Pocket`, `SerialDisposable` -> `SingleReplaceableDisposable` or `Slot`. +5. Convert factories: `Observable.Return` -> `Signal.Emit`, `Empty` -> `Signal.None`, `Never` -> `Signal.Silent`, `Throw` -> `Signal.Fail`, `Range` -> `Signal.Sequence`, `Defer` -> `Signal.Lazy`, `Timer` -> `Signal.After`, `Interval` -> `Signal.Pulse` or `Signal.Every`, `Create` -> `Signal.Create` or `Signal.CreateSafe`. +6. Keep code compiling with Rx-name compatibility aliases where useful: `Select`, `Where`, `Aggregate`, `Scan`, `Merge`, `Concat`, `SelectMany`, `CombineLatest`, `WithLatestFrom`, `Throttle`, and related names exist on the Primitives surface. +7. Prefer Primitives names in new or hot-path code: `Map`, `Keep`, `Reduce`, `Fold`, `Blend`, `Chain`, `FlatMap`/`Bind`, `SyncLatest`, `Latch`, `Calm`/`Stabilize`, `Probe`, `Shift`, `Expire`. +8. Replace schedulers with `Sequencer.Immediate`, `Sequencer.CurrentThread`, `ThreadPoolSequencer.Instance`, `TaskPoolSequencer.Instance`, `SynchronizationContextSequencer`, UI sequencers, or `VirtualClock` for tests. +9. Remove System.Reactive and ReactiveUI.Extensions package references only after imports and public APIs no longer require them. Keep bridge conversions at package edges. + +### New `xyz.Reactive` Project Consuming `.Reactive` Packages + +Use this path when an Rx-based source base should keep System.Reactive-facing APIs for existing consumers while sharing implementation with a lean `xyz` package. + +1. Create `xyz.Reactive` as a sibling project to `xyz`. Link or share implementation files instead of copying logic. +2. In shared implementation code, use neutral identifiers `RxVoid` and `ISequencer`. The lean project binds them to Primitives types; the reactive project aliases them to `System.Reactive.Unit` and `System.Reactive.Concurrency.IScheduler`. +3. Gate namespaces when package namespaces differ: + +```csharp +#if REACTIVE_SHIM +namespace xyz.Reactive; +#else +namespace xyz; +#endif +``` + +4. Add the `.Reactive` package set that matches the source surface: + +```bash +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.Reactive +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.Extensions.Reactive +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.Async.Reactive +``` + +5. Add only the matching `.Reactive` UI package when the project exposes UI scheduling: + +```bash +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.Wpf.Reactive +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.WinForms.Reactive +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.WinUI.Reactive +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.Blazor.Reactive +dotnet add xyz.Reactive/xyz.Reactive.csproj package ReactiveUI.Primitives.Maui.Reactive +``` + +6. If the repository does not centralize this already, configure `xyz.Reactive`: + +```xml + + $(DefineConstants);REACTIVE_SHIM + + + + + +``` + +7. Preserve Rx source compatibility first. Keep names such as `Select`, `Where`, `SelectMany`, `CombineLatest`, `Merge`, `Concat`, `Throttle`, and `WithLatestFrom` when that avoids unnecessary code churn. The `.Reactive` packages provide those names over the Primitives implementation. +8. Build `xyz` and `xyz.Reactive` side by side. The lean `xyz` package should avoid System.Reactive runtime dependencies; `xyz.Reactive` intentionally references System.Reactive and exposes `Unit`/`IScheduler`. +9. Update tests to run both package variants. Prefer TUnit/Microsoft Testing Platform in this repository and use only TUnit assertions. ## R3 And R3Async Bridges @@ -148,11 +240,11 @@ Use bridge methods only at boundaries. Keep internal pipelines in one model afte ## Framework And Platform Notes - General libraries target `net8.0`, `net9.0`, `net10.0`, `net11.0`, `net462`, `net472`, `net48`, and `net481`. -- `ReactiveUI.Primitives` also builds Android TFMs and Apple TFMs for platform sequencers in the base package. -- WPF and WinForms packages target Windows TFMs plus .NET Framework. -- WinUI targets `net*-windows10.0.19041.0`. -- MAUI targets `net9.0`, `net10.0`, and `net11.0`. -- Blazor targets the modern .NET TFMs. +- `ReactiveUI.Primitives` and `ReactiveUI.Primitives.Reactive` also build Android TFMs and Apple TFMs for platform sequencers in the base package family. +- WPF and WinForms packages, including `.Reactive` variants, target Windows TFMs plus .NET Framework. +- WinUI packages, including `.Reactive` variants, target `net*-windows10.0.19041.0`. +- MAUI packages, including `.Reactive` variants, target `net9.0`, `net10.0`, and `net11.0`. +- Blazor packages, including `.Reactive` variants, target the modern .NET TFMs. ## Repository Maintenance @@ -162,5 +254,5 @@ When editing this repository: - Build and test from `src`. - Tests use Microsoft.Testing.Platform with TUnit; write TUnit tests and TUnit assertions only. - Shipping public API baselines live under each package's `PublicAPI//PublicAPI.Shipped.txt` and `PublicAPI.Unshipped.txt`. -- `Skill.md` is the canonical skill file. `ReactiveUI.Primitives.csproj` packs it both at package root as `Skill.md` and at `.agents/skills/reactiveui-primitives/SKILL.md`. +- `Skill.md` is the canonical skill file. `ReactiveUI.Primitives.csproj` packs it both at package root as `Skill.md` and at `.agents/skills/reactiveui-primitives/SKILL.md`; keep this filename singular and casing intact. - Keep package guidance synchronized with packable projects in the solution. Tests, benchmarks, and `ReactiveUI.Primitives.R3Bridge.Generator` are not NuGet packages to add directly. diff --git a/src/Directory.Build.props b/src/Directory.Build.props index 0b909d63..82aa9213 100644 --- a/src/Directory.Build.props +++ b/src/Directory.Build.props @@ -96,6 +96,7 @@ + diff --git a/src/Directory.Packages.props b/src/Directory.Packages.props index f57e8f25..0948536f 100644 --- a/src/Directory.Packages.props +++ b/src/Directory.Packages.props @@ -9,7 +9,7 @@ - + diff --git a/src/Polyfills/AllowNullAttribute.cs b/src/Polyfills/AllowNullAttribute.cs new file mode 100644 index 00000000..8c890bb6 --- /dev/null +++ b/src/Polyfills/AllowNullAttribute.cs @@ -0,0 +1,14 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +// Polyfill implementation adapted from SimonCropp/Polyfill (https://github.com/SimonCropp/Polyfill). +#if !NETCOREAPP3_0_OR_GREATER && !NETSTANDARD2_1_OR_GREATER +namespace System.Diagnostics.CodeAnalysis; + +/// Specifies that is allowed as an input even if the corresponding type disallows it. +[ExcludeFromCodeCoverage] +[DebuggerNonUserCode] +[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property)] +internal sealed class AllowNullAttribute : Attribute; +#endif diff --git a/src/Primitives.Extensions.Shared/ReactiveExtensions.cs b/src/Primitives.Extensions.Shared/ReactiveExtensions.cs index e76662fd..66cb013c 100644 --- a/src/Primitives.Extensions.Shared/ReactiveExtensions.cs +++ b/src/Primitives.Extensions.Shared/ReactiveExtensions.cs @@ -22,6 +22,9 @@ public static class ReactiveExtensions /// Default backoff factor for : each retry doubles the previous delay. private const double DefaultBackoffFactor = 2.0; + /// Default match timeout for regex filters created from string patterns. + private static readonly TimeSpan DefaultRegexMatchTimeout = TimeSpan.FromSeconds(30); + /// Boolean reduction operators for a set of boolean observable sources. /// The sources. extension(IEnumerable> sources) @@ -906,7 +909,7 @@ public IObservable BufferUntil(char startsWith, char endsWith) => /// Regex pattern. /// Filtered sequence. public IObservable Filter(string regexPattern) => - source.Filter(new Regex(regexPattern, RegexOptions.None, TimeSpan.FromSeconds(1))); + source.Filter(new Regex(regexPattern, RegexOptions.None, DefaultRegexMatchTimeout)); /// Filters strings by regex. /// Regex. diff --git a/src/Primitives.Shared/Advanced/AsyncSubscriptionLifetime.cs b/src/Primitives.Shared/Advanced/AsyncSubscriptionLifetime.cs new file mode 100644 index 00000000..eb045fd8 --- /dev/null +++ b/src/Primitives.Shared/Advanced/AsyncSubscriptionLifetime.cs @@ -0,0 +1,90 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Owns cancellation and the eventual inner disposable for asynchronous signal subscriptions. +/// +/// Call exactly once after asynchronous setup has finished, even when setup faults or is canceled. +/// +public sealed class AsyncSubscriptionLifetime : IDisposable +{ + /// The cancellation source passed to the asynchronous subscription. + private readonly CancellationTokenSource _cts = new(); + + /// The inner disposable returned by the asynchronous subscription. + private readonly SingleDisposable _subscription = new(); + + /// Non-zero once the outer subscription has been disposed. + private int _disposed; + + /// Non-zero when disposal requested cancellation before the asynchronous subscription completed. + private int _canceled; + + /// Non-zero once the asynchronous subscription task has completed. + private int _completed; + + /// Gets the token supplied to the asynchronous subscription. + public CancellationToken Token => _cts.Token; + + /// Gets a value indicating whether disposal requested cancellation before asynchronous setup completed. + public bool IsCancellationRequested => Volatile.Read(ref _canceled) != 0; + + /// Assigns the disposable returned by asynchronous setup. + /// The returned disposable, or for an empty lifetime. + public void SetSubscription(IDisposable? disposable) => + _subscription.Create(disposable ?? EmptyDisposable.Instance); + + /// Marks asynchronous setup complete and releases the cancellation source when still owned here. + public void Complete() + { + Volatile.Write(ref _completed, 1); + if (Volatile.Read(ref _disposed) != 0) + { + return; + } + + _cts.Dispose(); + } + + /// + public void Dispose() + { + if (Interlocked.Exchange(ref _disposed, 1) != 0) + { + return; + } + + if (Volatile.Read(ref _completed) != 0) + { + _subscription.Dispose(); + _cts.Dispose(); + return; + } + + Volatile.Write(ref _canceled, 1); + CancelIgnoringDisposed(_cts); + _subscription.Dispose(); + _cts.Dispose(); + } + + /// Cancels the source while tolerating a concurrent completion disposing it first. + /// The cancellation source to cancel. + [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage] + private static void CancelIgnoringDisposed(CancellationTokenSource cts) + { + try + { + cts.Cancel(); + } + catch (ObjectDisposedException) + { + // Completion can release the CTS concurrently; disposal still continues with the inner subscription. + } + } +} diff --git a/src/Primitives.Shared/Advanced/CurrentThreadRequirement.cs b/src/Primitives.Shared/Advanced/CurrentThreadRequirement.cs new file mode 100644 index 00000000..8a833550 --- /dev/null +++ b/src/Primitives.Shared/Advanced/CurrentThreadRequirement.cs @@ -0,0 +1,27 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Shared current-thread requirement checks for advanced signals. +internal static class CurrentThreadRequirement +{ + /// Determines whether a source requires current-thread subscription. + /// The source value type. + /// The source observable. + /// when the source requires current-thread subscription. + public static bool IsRequired(IObservable source) + { + if (source is not IRequireCurrentThread currentThread) + { + return false; + } + + return currentThread.IsRequiredSubscribeOnCurrentThread(); + } +} diff --git a/src/Primitives.Shared/Advanced/MapIndexedSignal{TSource,TResult}.cs b/src/Primitives.Shared/Advanced/MapIndexedSignal{TSource,TResult}.cs new file mode 100644 index 00000000..0e9f7206 --- /dev/null +++ b/src/Primitives.Shared/Advanced/MapIndexedSignal{TSource,TResult}.cs @@ -0,0 +1,42 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Indexed map signal. +/// The source value type. +/// The projected value type. +public sealed class MapIndexedSignal : IRequireCurrentThread +{ + /// The source observable. + private readonly IObservable _source; + + /// The indexed selector. + private readonly Func _selector; + + /// Initializes a new instance of the class. + /// The source observable. + /// The indexed selector. + public MapIndexedSignal(IObservable source, Func selector) + { + _source = source; + _selector = selector; + } + + /// + public bool IsRequiredSubscribeOnCurrentThread() => + CurrentThreadRequirement.IsRequired(_source); + + /// + public IDisposable Subscribe(IObserver observer) + { + ArgumentExceptionHelper.ThrowIfNull(observer); + + return _source.Subscribe(new MapIndexedWitness(observer, _selector)); + } +} diff --git a/src/Primitives.Shared/Advanced/MapIndexedWitness{TSource,TResult}.cs b/src/Primitives.Shared/Advanced/MapIndexedWitness{TSource,TResult}.cs new file mode 100644 index 00000000..93c601a2 --- /dev/null +++ b/src/Primitives.Shared/Advanced/MapIndexedWitness{TSource,TResult}.cs @@ -0,0 +1,82 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Applies an indexed selector to source values. +/// The source value type. +/// The projected value type. +public sealed class MapIndexedWitness : IObserver +{ + /// The downstream observer. + private readonly IObserver _observer; + + /// The indexed selector. + private readonly Func _selector; + + /// The next zero-based index. + private int _index; + + /// Whether a terminal notification has been forwarded. + private bool _stopped; + + /// Initializes a new instance of the class. + /// The downstream observer. + /// The indexed selector. + public MapIndexedWitness(IObserver observer, Func selector) + { + _observer = observer; + _selector = selector; + } + + /// + public void OnNext(TSource value) + { + if (_stopped) + { + return; + } + + TResult result; + try + { + result = _selector(value, _index++); + } + catch (Exception error) when (!FatalExceptionHelper.IsFatal(error)) + { + OnError(error); + return; + } + + _observer.OnNext(result); + } + + /// + public void OnError(Exception error) + { + if (_stopped) + { + return; + } + + _stopped = true; + _observer.OnError(error); + } + + /// + public void OnCompleted() + { + if (_stopped) + { + return; + } + + _stopped = true; + _observer.OnCompleted(); + } +} diff --git a/src/Primitives.Shared/Advanced/MaxConcurrentBlendCoordinator{T}.cs b/src/Primitives.Shared/Advanced/MaxConcurrentBlendCoordinator{T}.cs new file mode 100644 index 00000000..b05794c4 --- /dev/null +++ b/src/Primitives.Shared/Advanced/MaxConcurrentBlendCoordinator{T}.cs @@ -0,0 +1,210 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Coordinates bounded-concurrency merging of enumerable observable sources. +/// The value type. +public sealed class MaxConcurrentBlendCoordinator : IDisposable +{ + /// Serializes enumeration, counters, and downstream callbacks. + private readonly Lock _gate = new(); + + /// Active subscriptions and enumerable lifetime. + private readonly MultipleDisposable _subscriptions = []; + + /// The downstream observer. + private readonly IObserver _observer; + + /// The source enumerator. + private IEnumerator>? _enumerator; + + /// The number of active inner sources. + private int _active; + + /// Whether all enumerable sources have been consumed. + private bool _enumerationCompleted; + + /// Whether a terminal notification has been emitted. + private bool _done; + + /// Initializes a new instance of the class. + /// The downstream observer. + public MaxConcurrentBlendCoordinator(IObserver observer) => _observer = observer; + + /// + public void Dispose() + { + var enumerator = _enumerator; + _enumerator = null; + enumerator?.Dispose(); + _subscriptions.Dispose(); + } + + /// Starts bounded-concurrency merging. + /// The enumerable sources. + /// The maximum number of active inner subscriptions. + /// The subscription cleanup. + public MaxConcurrentBlendCoordinator Run(IEnumerable> sources, int maxConcurrent) + { + _enumerator = sources.GetEnumerator(); + + for (var i = 0; i < maxConcurrent; i++) + { + if (!SubscribeNext()) + { + break; + } + } + + return this; + } + + /// Subscribes to the next enumerable source when one is available. + /// when a new inner source was subscribed. + private bool SubscribeNext() + { + var next = TakeNextSource(out var failed); + if (failed) + { + Dispose(); + } + + if (next is null) + { + return false; + } + + OnceDisposable inner = new(); + _subscriptions.Add(inner); + inner.Disposable = next.Subscribe(OnInnerNext, OnAnyError, () => OnInnerCompleted(inner)); + return true; + } + + /// Reads the next source from the enumerable under the gate. + /// Set to when reading the next source failed. + /// The next source, or when no source should be subscribed. + private IObservable? TakeNextSource(out bool failed) + { + failed = false; + lock (_gate) + { + if (_done || _enumerationCompleted) + { + return null; + } + + var enumerator = _enumerator; + try + { + if (enumerator?.MoveNext() != true) + { + _enumerationCompleted = true; + DisposeEnumerator(); + TryCompleteCore(); + return null; + } + } + catch (Exception error) when (!FatalExceptionHelper.IsFatal(error)) + { + FailCore(error); + failed = true; + return null; + } + + var next = enumerator!.Current; + if (next is null) + { + FailCore(new InvalidOperationException("Blend source contained null.")); + failed = true; + return null; + } + + _active++; + return next; + } + } + + /// Forwards an inner value under the serialization gate. + /// The value to forward. + private void OnInnerNext(T value) + { + lock (_gate) + { + if (!_done) + { + _observer.OnNext(value); + } + } + } + + /// Forwards the first terminal error and releases active subscriptions. + /// The error to forward. + private void OnAnyError(Exception error) + { + lock (_gate) + { + if (_done) + { + return; + } + + FailCore(error); + } + + Dispose(); + } + + /// Completes one inner source and starts another if possible. + /// The completed inner subscription. + private void OnInnerCompleted(OnceDisposable inner) + { + _subscriptions.Remove(inner); + + lock (_gate) + { + if (_done) + { + return; + } + + _active--; + TryCompleteCore(); + } + + SubscribeNext(); + } + + /// Marks the coordinator failed and forwards the error. Caller must hold the gate. + /// The terminal error. + private void FailCore(Exception error) + { + _done = true; + _observer.OnError(error); + } + + /// Completes downstream once enumeration and all active sources have completed. Caller must hold the gate. + private void TryCompleteCore() + { + if (_done || !_enumerationCompleted || _active != 0) + { + return; + } + + _done = true; + _observer.OnCompleted(); + } + + /// Disposes the enumerable source exactly once. + private void DisposeEnumerator() + { + var enumerator = _enumerator; + _enumerator = null; + enumerator?.Dispose(); + } +} diff --git a/src/Primitives.Shared/Advanced/MaxConcurrentEnumerableBlendSignal{T}.cs b/src/Primitives.Shared/Advanced/MaxConcurrentEnumerableBlendSignal{T}.cs new file mode 100644 index 00000000..2e019512 --- /dev/null +++ b/src/Primitives.Shared/Advanced/MaxConcurrentEnumerableBlendSignal{T}.cs @@ -0,0 +1,37 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Enumerable Blend signal with bounded concurrency. +/// The value type. +public sealed class MaxConcurrentEnumerableBlendSignal : IObservable +{ + /// The sources to merge. + private readonly IEnumerable> _sources; + + /// The maximum number of active inner subscriptions. + private readonly int _maxConcurrent; + + /// Initializes a new instance of the class. + /// The sources to merge. + /// The maximum number of active inner subscriptions. + public MaxConcurrentEnumerableBlendSignal(IEnumerable> sources, int maxConcurrent) + { + _sources = sources; + _maxConcurrent = maxConcurrent; + } + + /// + public IDisposable Subscribe(IObserver observer) + { + ArgumentExceptionHelper.ThrowIfNull(observer); + + return new MaxConcurrentBlendCoordinator(observer).Run(_sources, _maxConcurrent); + } +} diff --git a/src/Primitives.Shared/Advanced/ObserverSinkLifetime.cs b/src/Primitives.Shared/Advanced/ObserverSinkLifetime.cs new file mode 100644 index 00000000..aa65f113 --- /dev/null +++ b/src/Primitives.Shared/Advanced/ObserverSinkLifetime.cs @@ -0,0 +1,82 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Shared terminal and subscription handling for advanced observer sinks. +internal static class ObserverSinkLifetime +{ + /// Disposes a sink and its upstream subscription. + /// The stopped flag. + /// The upstream subscription slot. + public static void Dispose(ref int stopped, SingleReplaceableDisposable subscription) + { + Interlocked.Exchange(ref stopped, 1); + subscription.Dispose(); + } + + /// Gets a value indicating whether the sink has stopped. + /// The stopped flag. + /// when the sink has stopped. + public static bool IsStopped(ref int stopped) => Volatile.Read(ref stopped) != 0; + + /// Assigns the upstream subscription and disposes it when the sink has already stopped. + /// The stopped flag. + /// The upstream subscription slot. + /// The upstream subscription. + public static void SetSubscription(ref int stopped, SingleReplaceableDisposable slot, IDisposable subscription) + { + slot.Create(subscription); + if (Volatile.Read(ref stopped) == 0) + { + return; + } + + slot.Dispose(); + } + + /// Forwards completion exactly once and disposes the upstream subscription. + /// The observer value type. + /// The stopped flag. + /// The upstream subscription slot. + /// The downstream observer. + public static void Complete( + ref int stopped, + SingleReplaceableDisposable subscription, + IObserver observer) + { + if (Interlocked.Exchange(ref stopped, 1) != 0) + { + return; + } + + using var _ = subscription; + observer.OnCompleted(); + } + + /// Forwards an error exactly once and disposes the upstream subscription. + /// The observer value type. + /// The stopped flag. + /// The upstream subscription slot. + /// The downstream observer. + /// The terminal error. + public static void Error( + ref int stopped, + SingleReplaceableDisposable subscription, + IObserver observer, + Exception terminalError) + { + if (Interlocked.Exchange(ref stopped, 1) != 0) + { + return; + } + + using var _ = subscription; + observer.OnError(terminalError); + } +} diff --git a/src/Primitives.Shared/Advanced/SelectManyEnumerableObserver{TSource,TResult}.cs b/src/Primitives.Shared/Advanced/SelectManyEnumerableObserver{TSource,TResult}.cs new file mode 100644 index 00000000..e9c543a4 --- /dev/null +++ b/src/Primitives.Shared/Advanced/SelectManyEnumerableObserver{TSource,TResult}.cs @@ -0,0 +1,87 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Observer for enumerable SelectMany. +/// The source value type. +/// The result value type. +public sealed class SelectManyEnumerableObserver : IObserver, IDisposable +{ + /// The downstream observer. + private readonly IObserver _observer; + + /// The enumerable projection. + private readonly Func> _selector; + + /// The upstream subscription. + private readonly SingleReplaceableDisposable _subscription = new(); + + /// Non-zero after terminal notification or disposal. + private int _stopped; + + /// Initializes a new instance of the class. + /// The downstream observer. + /// The enumerable projection. + public SelectManyEnumerableObserver(IObserver observer, Func> selector) + { + _observer = observer; + _selector = selector; + } + + /// + public void Dispose() => ObserverSinkLifetime.Dispose(ref _stopped, _subscription); + + /// + public void OnCompleted() => ObserverSinkLifetime.Complete(ref _stopped, _subscription, _observer); + + /// + public void OnError(Exception error) => ObserverSinkLifetime.Error(ref _stopped, _subscription, _observer, error); + + /// + public void OnNext(TSource value) + { + if (ObserverSinkLifetime.IsStopped(ref _stopped)) + { + return; + } + + try + { + var values = _selector(value); + if (values is null) + { + ObserverSinkLifetime.Error( + ref _stopped, + _subscription, + _observer, + new InvalidOperationException("SelectMany selector returned null.")); + return; + } + + foreach (var result in values) + { + if (ObserverSinkLifetime.IsStopped(ref _stopped)) + { + return; + } + + _observer.OnNext(result); + } + } + catch (Exception error) when (!FatalExceptionHelper.IsFatal(error)) + { + ObserverSinkLifetime.Error(ref _stopped, _subscription, _observer, error); + } + } + + /// Assigns the upstream subscription. + /// The upstream subscription. + public void SetSubscription(IDisposable subscription) => + ObserverSinkLifetime.SetSubscription(ref _stopped, _subscription, subscription); +} diff --git a/src/Primitives.Shared/Advanced/SelectManyEnumerableSignal{TSource,TResult}.cs b/src/Primitives.Shared/Advanced/SelectManyEnumerableSignal{TSource,TResult}.cs new file mode 100644 index 00000000..9f4a06c7 --- /dev/null +++ b/src/Primitives.Shared/Advanced/SelectManyEnumerableSignal{TSource,TResult}.cs @@ -0,0 +1,40 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Signal that projects each value to an enumerable sequence and emits the enumerable values. +/// The source value type. +/// The result value type. +public sealed class SelectManyEnumerableSignal : IObservable +{ + /// The source observable. + private readonly IObservable _source; + + /// The enumerable projection. + private readonly Func> _selector; + + /// Initializes a new instance of the class. + /// The source observable. + /// The enumerable projection. + public SelectManyEnumerableSignal(IObservable source, Func> selector) + { + _source = source; + _selector = selector; + } + + /// + public IDisposable Subscribe(IObserver observer) + { + ArgumentExceptionHelper.ThrowIfNull(observer); + + SelectManyEnumerableObserver sink = new(observer, _selector); + sink.SetSubscription(_source.Subscribe(sink)); + return sink; + } +} diff --git a/src/Primitives.Shared/Advanced/SubscribeSafeObserver{T}.cs b/src/Primitives.Shared/Advanced/SubscribeSafeObserver{T}.cs new file mode 100644 index 00000000..b302f5f4 --- /dev/null +++ b/src/Primitives.Shared/Advanced/SubscribeSafeObserver{T}.cs @@ -0,0 +1,59 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Observer that turns downstream OnNext exceptions into a terminal error and upstream disposal. +/// The value type. +public sealed class SubscribeSafeObserver : IObserver, IDisposable +{ + /// The wrapped observer. + private readonly IObserver _observer; + + /// The upstream subscription. + private readonly SingleReplaceableDisposable _subscription = new(); + + /// Non-zero after terminal notification or disposal. + private int _stopped; + + /// Initializes a new instance of the class. + /// The wrapped observer. + public SubscribeSafeObserver(IObserver observer) => _observer = observer; + + /// + public void Dispose() => ObserverSinkLifetime.Dispose(ref _stopped, _subscription); + + /// + public void OnCompleted() => ObserverSinkLifetime.Complete(ref _stopped, _subscription, _observer); + + /// + public void OnError(Exception error) => ObserverSinkLifetime.Error(ref _stopped, _subscription, _observer, error); + + /// + public void OnNext(T value) + { + if (ObserverSinkLifetime.IsStopped(ref _stopped)) + { + return; + } + + try + { + _observer.OnNext(value); + } + catch (Exception error) when (!FatalExceptionHelper.IsFatal(error)) + { + ObserverSinkLifetime.Error(ref _stopped, _subscription, _observer, error); + } + } + + /// Assigns the upstream subscription. + /// The upstream subscription. + public void SetSubscription(IDisposable subscription) => + ObserverSinkLifetime.SetSubscription(ref _stopped, _subscription, subscription); +} diff --git a/src/Primitives.Shared/Advanced/SynchronizeObjectSignal{T}.cs b/src/Primitives.Shared/Advanced/SynchronizeObjectSignal{T}.cs new file mode 100644 index 00000000..6528c51f --- /dev/null +++ b/src/Primitives.Shared/Advanced/SynchronizeObjectSignal{T}.cs @@ -0,0 +1,39 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Object-gated Synchronize compatibility signal. +/// The value type. +public sealed class SynchronizeObjectSignal : IObservable +{ + /// The source observable. + private readonly IObservable _source; + + /// The shared gate. + private readonly object _gate; + + /// Initializes a new instance of the class. + /// The source observable. + /// The gate shared across subscriptions and other synchronized sequences. + public SynchronizeObjectSignal(IObservable source, object gate) + { + _source = source; + _gate = gate; + } + + /// + public IDisposable Subscribe(IObserver observer) + { + ArgumentExceptionHelper.ThrowIfNull(observer); + + SynchronizeObjectWitness sink = new(observer, _gate); + sink.SetSubscription(_source.Subscribe(sink)); + return sink; + } +} diff --git a/src/Primitives.Shared/Advanced/SynchronizeObjectWitness{T}.cs b/src/Primitives.Shared/Advanced/SynchronizeObjectWitness{T}.cs new file mode 100644 index 00000000..ff4b349b --- /dev/null +++ b/src/Primitives.Shared/Advanced/SynchronizeObjectWitness{T}.cs @@ -0,0 +1,66 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Observer that serializes notifications using an object gate. +/// The value type. +public sealed class SynchronizeObjectWitness : IObserver, IDisposable +{ + /// The downstream observer. + private readonly IObserver _observer; + + /// The gate that serializes every forwarded notification. + private readonly object _gate; + + /// The upstream subscription. + private IDisposable? _subscription; + + /// Initializes a new instance of the class. + /// The downstream observer. + /// The gate shared with other synchronized observers. + public SynchronizeObjectWitness(IObserver observer, object gate) + { + _observer = observer; + _gate = gate; + } + + /// + public void OnNext(T value) + { + lock (_gate) + { + _observer.OnNext(value); + } + } + + /// + public void OnError(Exception error) + { + lock (_gate) + { + _observer.OnError(error); + } + } + + /// + public void OnCompleted() + { + lock (_gate) + { + _observer.OnCompleted(); + } + } + + /// Assigns the upstream subscription. + /// The upstream subscription. + public void SetSubscription(IDisposable subscription) => SinkSubscription.Set(ref _subscription, subscription); + + /// + public void Dispose() => SinkSubscription.Dispose(ref _subscription); +} diff --git a/src/Primitives.Shared/Advanced/TaskChainCoordinatorState.cs b/src/Primitives.Shared/Advanced/TaskChainCoordinatorState.cs new file mode 100644 index 00000000..e7a0a376 --- /dev/null +++ b/src/Primitives.Shared/Advanced/TaskChainCoordinatorState.cs @@ -0,0 +1,38 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// State transitions for . +internal static class TaskChainCoordinatorState +{ + /// Marks the active inner source complete and drains when the coordinator has not already stopped. + /// The task result type. + /// The coordinator state gate. + /// A value indicating whether a terminal notification has already been emitted. + /// A value indicating whether an inner source is active. + /// The coordinator to drain. + public static void OnInnerCompleted( + Lock gate, + ref bool done, + ref bool active, + TaskChainCoordinator coordinator) + { + lock (gate) + { + if (done) + { + return; + } + + active = false; + } + + coordinator.Drain(); + } +} diff --git a/src/Primitives.Shared/Advanced/TaskChainCoordinator{T}.cs b/src/Primitives.Shared/Advanced/TaskChainCoordinator{T}.cs new file mode 100644 index 00000000..cc1bdcc3 --- /dev/null +++ b/src/Primitives.Shared/Advanced/TaskChainCoordinator{T}.cs @@ -0,0 +1,148 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Coordinates sequential task-source concatenation without a map adapter. +/// The task result type. +public sealed class TaskChainCoordinator : IDisposable +{ + /// Guards the queue and active/completed flags. + private readonly Lock _gate = new(); + + /// Queued task signals awaiting the active one to complete. + private readonly Queue> _queue = new(); + + /// Active subscriptions. + private readonly MultipleDisposable _pocket = []; + + /// The downstream observer. + private readonly IObserver _observer; + + /// A value indicating whether an inner task signal is active. + private bool _active; + + /// A value indicating whether the outer task source completed. + private bool _outerCompleted; + + /// A value indicating whether a terminal notification has been emitted. + private bool _done; + + /// Initializes a new instance of the class. + /// The downstream observer. + public TaskChainCoordinator(IObserver observer) => _observer = observer; + + /// + public void Dispose() => _pocket.Dispose(); + + /// Subscribes to the outer task source. + /// The outer task source. + /// The coordinator that owns the subscription cleanup. + public TaskChainCoordinator Run(IObservable> sources) + { + _pocket.Add(sources.Subscribe(OnTask, OnError, OnOuterCompleted)); + return this; + } + + /// Subscribes the next queued task signal, or completes when the task chain is drained. + internal void Drain() + { + IObservable? next = null; + lock (_gate) + { + if (_done || _active) + { + return; + } + + if (_queue.Count > 0) + { + _active = true; + next = _queue.Dequeue(); + } + else if (_outerCompleted) + { + _done = true; + _observer.OnCompleted(); + } + } + + if (next is null) + { + return; + } + + _pocket.Add(next.Subscribe(_observer.OnNext, OnError, OnInnerCompleted)); + } + + /// Queues a task as a task-backed signal and pumps the drain. + /// The task to observe in source order. + private void OnTask(Task task) + { + IObservable source; + try + { + source = Signal.FromTask(task); + } + catch (Exception error) when (!FatalExceptionHelper.IsFatal(error)) + { + OnError(error); + return; + } + + lock (_gate) + { + if (_done) + { + return; + } + + _queue.Enqueue(source); + } + + Drain(); + } + + /// Marks the outer task source complete and pumps the drain. + private void OnOuterCompleted() + { + lock (_gate) + { + if (_done) + { + return; + } + + _outerCompleted = true; + } + + Drain(); + } + + /// Marks the active task signal complete and pumps the drain. + private void OnInnerCompleted() => + TaskChainCoordinatorState.OnInnerCompleted(_gate, ref _done, ref _active, this); + + /// Forwards an error and terminates active subscriptions. + /// The terminal error. + private void OnError(Exception error) + { + lock (_gate) + { + if (_done) + { + return; + } + + _done = true; + _observer.OnError(error); + } + + Dispose(); + } +} diff --git a/src/Primitives.Shared/Advanced/TaskChainSignal{T}.cs b/src/Primitives.Shared/Advanced/TaskChainSignal{T}.cs new file mode 100644 index 00000000..87717831 --- /dev/null +++ b/src/Primitives.Shared/Advanced/TaskChainSignal{T}.cs @@ -0,0 +1,29 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Advanced; +#else +namespace ReactiveUI.Primitives.Advanced; +#endif + +/// Task-source Chain/Concat signal. +/// The task result type. +public sealed class TaskChainSignal : IObservable +{ + /// The outer task source. + private readonly IObservable> _sources; + + /// Initializes a new instance of the class. + /// The outer task source. + public TaskChainSignal(IObservable> sources) => _sources = sources; + + /// + public IDisposable Subscribe(IObserver observer) + { + ArgumentExceptionHelper.ThrowIfNull(observer); + + return new TaskChainCoordinator(observer).Run(_sources); + } +} diff --git a/src/Primitives.Shared/ConnectableSignalExtensions.cs b/src/Primitives.Shared/ConnectableSignalExtensions.cs index 473c4284..6da1480f 100644 --- a/src/Primitives.Shared/ConnectableSignalExtensions.cs +++ b/src/Primitives.Shared/ConnectableSignalExtensions.cs @@ -25,6 +25,11 @@ public IObservable AutoShare() return AutoShareGate.For(source); } + /// Shares a single subscription while observers are present. System.Reactive name for AutoShare. + /// A reference-counted sequence. + public IObservable RefCount() => + source.AutoShare(); + /// Connects on the first observer subscription. /// A sequence that connects after the first subscription. public IObservable AutoConnect() => @@ -70,6 +75,53 @@ public ConnectableSignal ShareLive() => public ConnectableSignal Share() => source.ShareLive(); + /// Creates a connectable live signal. System.Reactive name for ShareLive. + /// A connectable live signal. + public ConnectableSignal Publish() => + source.ShareLive(); + + /// Multicasts source values through a live hub and applies a selector. + /// The selected value type. + /// The selector applied to the connectable signal before it is connected. + /// A sequence returned by while the source is connected. + /// or is . + public IObservable Publish(Func, IObservable> selector) + { + ArgumentExceptionHelper.ThrowIfNull(source); + + ArgumentExceptionHelper.ThrowIfNull(selector); + + return Signal.Create(observer => + { + var connectable = source.Publish(); + IObservable selected; + try + { + selected = selector(connectable); + } + catch (Exception error) when (!FatalExceptionHelper.IsFatal(error)) + { + observer.OnError(error); + return EmptyDisposable.Instance; + } + + if (selected is null) + { + observer.OnError(new InvalidOperationException("Publish selector returned null.")); + return EmptyDisposable.Instance; + } + + var subscription = selected.Subscribe(observer); + var connection = connectable.Connect(); + return new MultipleDisposable(subscription, connection); + }); + } + + /// Replays all source values through an unbounded replay hub. + /// A connectable replay signal. + public ConnectableSignal ReplayLive() => + source.Multicast(new ReplaySignal()); + /// Replays source values through a bounded replay hub. /// Maximum number of values to replay. /// A connectable replay signal. @@ -83,6 +135,11 @@ public ConnectableSignal ReplayLive(int bufferSize) => public ConnectableSignal ReplayLive(int bufferSize, TimeSpan window) => source.Multicast(new ReplaySignal(bufferSize, window)); + /// Replays all source values through an unbounded replay hub. + /// A connectable replay signal. + public ConnectableSignal Replay() => + source.ReplayLive(); + /// Replays source values through a bounded replay hub. /// Maximum number of values to replay. /// A connectable replay signal. diff --git a/src/Primitives.Shared/FatalExceptionHelper.cs b/src/Primitives.Shared/FatalExceptionHelper.cs new file mode 100644 index 00000000..f58d0a79 --- /dev/null +++ b/src/Primitives.Shared/FatalExceptionHelper.cs @@ -0,0 +1,27 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive; +#else +namespace ReactiveUI.Primitives; +#endif + +/// Identifies runtime exceptions that should not be converted into observable error notifications. +internal static class FatalExceptionHelper +{ + /// Determines whether an exception represents a fatal runtime failure. + /// The exception to classify. + /// when the exception should be allowed to propagate. + internal static bool IsFatal(Exception error) => + error is + StackOverflowException or + AccessViolationException or + AppDomainUnloadedException or + BadImageFormatException or + CannotUnloadAppDomainException or + InvalidProgramException or + System.Threading.ThreadAbortException or + (OutOfMemoryException and not InsufficientMemoryException); +} diff --git a/src/Primitives.Shared/LinqExtensions.BlendEnumerable.cs b/src/Primitives.Shared/LinqExtensions.BlendEnumerable.cs index 732492cb..432e40c0 100644 --- a/src/Primitives.Shared/LinqExtensions.BlendEnumerable.cs +++ b/src/Primitives.Shared/LinqExtensions.BlendEnumerable.cs @@ -24,6 +24,18 @@ public IObservable Blend() return new EnumerableBlendSignal(sources); } + + /// Concurrently merges the supplied observable sources with a maximum number of active subscriptions. + /// The maximum number of sources to subscribe to at the same time. + /// An observable that forwards values from every source. + public IObservable Blend(int maxConcurrent) + { + ArgumentExceptionHelper.ThrowIfNull(sources); + + ArgumentOutOfRangeExceptionHelper.ThrowIfNegativeOrZero(maxConcurrent); + + return maxConcurrent == int.MaxValue ? sources.Blend() : new MaxConcurrentEnumerableBlendSignal(sources, maxConcurrent); + } } /// Dedicated signal for enumerable Blend sources. diff --git a/src/Primitives.Shared/SignalOperatorMixins.cs b/src/Primitives.Shared/SignalOperatorMixins.cs index 2a6f24ad..c2fe255d 100644 --- a/src/Primitives.Shared/SignalOperatorMixins.cs +++ b/src/Primitives.Shared/SignalOperatorMixins.cs @@ -114,6 +114,20 @@ public IObservable Map(Func selector) return new MapSignal(source, selector); } + /// Projects each element and its zero-based index into a new form. + /// The type of the elements in the result sequence. + /// A transform function to apply to each source element and its index. + /// An observable sequence whose elements are the result of invoking the transform on each source element and index. + /// or is . + public IObservable MapIndexed(Func selector) + { + ArgumentExceptionHelper.ThrowIfNull(source); + + ArgumentExceptionHelper.ThrowIfNull(selector); + + return new MapIndexedSignal(source, selector); + } + /// /// Projects each element of an observable sequence into a new form by incorporating state that is passed to the /// selector function. @@ -530,6 +544,22 @@ public IObservable KeepNotNull() } } + /// Combining operators for an observable source of tasks. + /// The outer sequence of task sources. + /// The task result type. + extension(IObservable> sources) + { + /// Subscribes to task results one at a time in source order. + /// A sequence that emits each task result after the previous task signal completes. + /// is . + public IObservable Chain() + { + ArgumentExceptionHelper.ThrowIfNull(sources); + + return new TaskChainSignal(sources); + } + } + /// Type-filtering and casting operators for an untyped observable source. /// The source sequence. extension(IObservable source) @@ -565,6 +595,17 @@ public IObservable CastTo() } } + /// Signal-conversion operators for a task source. + /// The task to convert. + /// The task result type. + extension(Task task) + { + /// Converts a task to a signal that emits the task result. + /// A signal that emits the completed task result or faults with the task error. + /// is . + public IObservable ToSignal() => Signal.FromTask(task); + } + /// Creates the optimized range-backed combine-latest sequence. /// The result value type. /// The left range source. diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.cs b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.cs index a158ec97..649162c8 100644 --- a/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.cs +++ b/src/Primitives.Shared/SignalOperatorParityMixins.RxNames.cs @@ -15,6 +15,36 @@ namespace ReactiveUI.Primitives; /// public static partial class LinqExtensions { + /// System.Reactive-named combining operators for enumerable observable sources. + /// The observable sources. + /// The value type. + extension(IEnumerable> sources) + { + /// Concurrently merges the supplied observable sources. System.Reactive name for Blend. + /// An observable that forwards values from every source. + /// is . + public IObservable Merge() + { + ArgumentExceptionHelper.ThrowIfNull(sources); + + return sources.Blend(); + } + + /// Concurrently merges observable sources with a maximum number of active subscriptions. + /// The maximum number of sources to subscribe to at the same time. + /// An observable that forwards values from every source. + /// is . + /// is less than or equal to zero. + public IObservable Merge(int maxConcurrent) + { + ArgumentExceptionHelper.ThrowIfNull(sources); + + ArgumentOutOfRangeExceptionHelper.ThrowIfNegativeOrZero(maxConcurrent); + + return sources.Blend(maxConcurrent); + } + } + /// System.Reactive-named combining operators for an observable source of inner observable sequences. /// The outer sequence of inner sequences. /// The value type. @@ -87,6 +117,53 @@ public IObservable Dematerialize() /// The value type. extension(IObservable source) { + /// Subscribes an observer with downstream exception protection. + /// The observer to subscribe. + /// A disposable that cancels the subscription. + /// or is . + public IDisposable SubscribeSafe(IObserver observer) + { + ArgumentExceptionHelper.ThrowIfNull(source); + + ArgumentExceptionHelper.ThrowIfNull(observer); + + SubscribeSafeObserver safe = new(observer); + safe.SetSubscription(source.Subscribe(safe)); + return safe; + } + + /// Subscribes callbacks with downstream exception protection. + /// The action to invoke for each value. + /// The action to invoke for an error. + /// A disposable that cancels the subscription. + /// A required argument is . + public IDisposable SubscribeSafe(Action onNext, Action onError) => + source.SubscribeSafe(Witness.Create(onNext, onError)); + + /// Subscribes callbacks with downstream exception protection. + /// The action to invoke for each value. + /// The action to invoke for an error. + /// The action to invoke when the sequence completes. + /// A disposable that cancels the subscription. + /// A required argument is . + public IDisposable SubscribeSafe(Action onNext, Action onError, Action onCompleted) => + source.SubscribeSafe(Witness.Create(onNext, onError, onCompleted)); + + /// Subscribes terminal callbacks with downstream exception protection. + /// The action to invoke for an error. + /// A disposable that cancels the subscription. + /// A required argument is . + public IDisposable SubscribeSafe(Action onError) => + source.SubscribeSafe(Witness.Create(static _ => { }, onError)); + + /// Subscribes terminal callbacks with downstream exception protection. + /// The action to invoke for an error. + /// The action to invoke when the sequence completes. + /// A disposable that cancels the subscription. + /// A required argument is . + public IDisposable SubscribeSafe(Action onError, Action onCompleted) => + source.SubscribeSafe(Witness.Create(static _ => { }, onError, onCompleted)); + /// Invokes an action for each value while preserving the sequence. System.Reactive name for Tap. /// The action to invoke for each value. /// The source values after the action has run. @@ -132,6 +209,28 @@ public IObservable Do(Action onNext, Action onCompleted) return new TapSignal(source, onNext, static _ => { }, onCompleted); } + /// Invokes actions for each value, error, and completion while preserving the sequence. System.Reactive name for Tap. + /// The action to invoke for each value. + /// The action to invoke for an error. + /// The action to invoke when the sequence completes. + /// The source values after the actions have run. + /// A required argument is . + public IObservable Do( + Action onNext, + Action onError, + Action onCompleted) + { + ArgumentExceptionHelper.ThrowIfNull(source); + + ArgumentExceptionHelper.ThrowIfNull(onNext); + + ArgumentExceptionHelper.ThrowIfNull(onError); + + ArgumentExceptionHelper.ThrowIfNull(onCompleted); + + return new TapSignal(source, onNext, onError, onCompleted); + } + /// /// Serializes notifications behind a gate so downstream operators observe the single-threaded /// OnNext* then OnError|OnCompleted grammar even when the source delivers @@ -154,8 +253,6 @@ public IObservable Synchronize() /// The gate shared with other synchronized sequences. /// A sequence that forwards the source notifications one at a time under the shared gate. /// or is . - [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0001:Simplify Names", Justification = "The argument validation uses ArgumentExceptionHelper")] - [System.Diagnostics.CodeAnalysis.SuppressMessage("Modernization", "SST2000:Use ArgumentNullException.ThrowIfNull", Justification = "Uses variable types")] public IObservable Synchronize(Lock gate) { ArgumentExceptionHelper.ThrowIfNull(source); @@ -168,6 +265,38 @@ public IObservable Synchronize(Lock gate) return new SynchronizeSignal(source, gate); } +#if NET9_0_OR_GREATER + /// Serializes notifications behind an object gate. System.Reactive name for object-gated synchronization. + /// The gate shared with other synchronized sequences. + /// A sequence that forwards the source notifications one at a time under the shared gate. + /// or is . + public IObservable Synchronize(object gate) + { + ArgumentExceptionHelper.ThrowIfNull(source); + + ArgumentExceptionHelper.ThrowIfNull(gate); + + return new SynchronizeObjectSignal(source, gate); + } +#endif + + /// Serializes notifications behind an object gate when a caller cannot provide a dedicated lock gate. + /// The gate shared with other synchronized sequences. + /// A sequence that forwards the source notifications one at a time under the shared gate. + /// or is . + public IObservable SynchronizeObject(object gate) + { +#if NET9_0_OR_GREATER + return LinqExtensions.Synchronize(source, gate); +#else + ArgumentExceptionHelper.ThrowIfNull(source); + + ArgumentExceptionHelper.ThrowIfNull(gate); + + return new SynchronizeObjectSignal(source, gate); +#endif + } + /// Invokes a stateful action for each value while preserving the sequence. State-carrying name for TapWith. /// The state type. /// The state passed to . @@ -265,7 +394,67 @@ public IObservable IgnoreElements() return new IgnoreValuesSignal(source); } - /// Projects each value to an inner sequence and merges the results. LINQ name for FlatMap. + /// Prepends values before the source sequence. System.Reactive name for Prepend. + /// The values to emit before the source. + /// A sequence that emits before the source values. + /// or is . + public IObservable StartWith(params T[] values) => + source.Prepend(values); + + /// Prepends values before the source sequence. System.Reactive name for Prepend. + /// The values to emit before the source. + /// A sequence that emits before the source values. + /// or is . + public IObservable StartWith(IEnumerable values) => + source.Prepend(values); + + /// Collects values into time-windowed batches. System.Reactive name for Collect. + /// The duration of each buffer window. + /// A sequence that emits non-empty batches of source values. + /// is . + public IObservable> Buffer(TimeSpan timeSpan) => + source.Collect(timeSpan); + + /// Collects values into time-windowed batches on the supplied scheduler. + /// The duration of each buffer window. + /// The scheduler used to schedule buffer flushes. + /// A sequence that emits non-empty batches of source values. + /// or is . + public IObservable> Buffer(TimeSpan timeSpan, ISequencer scheduler) => + source.Collect(timeSpan, scheduler); + + /// Invokes an action when the subscription terminates or is disposed. System.Reactive name for OnCleanup. + /// The action to invoke exactly once. + /// A sequence that mirrors the source and invokes on cleanup. + /// or is . + public IObservable Finally(Action finallyAction) => + source.OnCleanup(finallyAction); + + /// Emits a value only after no newer value arrives within the quiet period. System.Reactive name for Calm. + /// The quiet period. + /// A sequence that emits the latest value after each quiet period. + /// is . + public IObservable Throttle(TimeSpan dueTime) => + source.Calm(dueTime); + + /// Emits a value only after no newer value arrives within the scheduler quiet period. System.Reactive name for Calm. + /// The quiet period. + /// The scheduler used to schedule quiet-period timers. + /// A sequence that emits the latest value after each quiet period. + /// or is . + public IObservable Throttle(TimeSpan dueTime, ISequencer scheduler) => + source.Calm(dueTime, scheduler); + + /// Handles errors of the specified type by switching to a replacement sequence. + /// The exception type to handle. + /// The function that produces a replacement sequence for handled errors. + /// A sequence that switches to the handler result for matching errors. + /// or is . + public IObservable Catch(Func> handler) + where TException : Exception => + source.Recover(handler); + + /// Projects each value to an inner sequence and merges the results. LINQ name for concurrent flattening. /// The inner value type. /// The function that projects each source value to an inner sequence. /// A sequence containing the merged values of every inner sequence. @@ -276,10 +465,38 @@ public IObservable SelectMany(Func> se ArgumentExceptionHelper.ThrowIfNull(selector); - return new FlatMapSignal(source, selector); + return source.Map(selector).Merge(); + } + + /// Projects each value to the same inner sequence and merges the results. + /// The inner value type. + /// The inner sequence used for each source value. + /// A sequence containing the merged values of every inner sequence. + /// or is . + public IObservable SelectMany(IObservable other) + { + ArgumentExceptionHelper.ThrowIfNull(source); + + ArgumentExceptionHelper.ThrowIfNull(other); + + return source.Map(_ => other).Merge(); } - /// Projects each value to an inner sequence and combines each pair with a result selector. LINQ name for FlatMap. + /// Projects each value to an enumerable sequence and emits the projected values. + /// The projected value type. + /// The function that projects each source value to enumerable values. + /// A sequence containing the projected enumerable values. + /// or is . + public IObservable SelectMany(Func> selector) + { + ArgumentExceptionHelper.ThrowIfNull(source); + + ArgumentExceptionHelper.ThrowIfNull(selector); + + return new SelectManyEnumerableSignal(source, selector); + } + + /// Projects each value to an inner sequence and concurrently combines each pair with a result selector. /// The inner value type. /// The result value type. /// The function that projects each source value to an inner sequence. @@ -294,7 +511,20 @@ public IObservable SelectMany( ArgumentExceptionHelper.ThrowIfNull(resultSelector); - return new FlatMapResultSignal(source, collectionSelector, resultSelector); + return source.Map(value => collectionSelector(value).Map(inner => resultSelector(value, inner))).Merge(); + } + + /// Merges this sequence with another observable sequence. System.Reactive name for Blend. + /// The second sequence to merge. + /// A sequence containing values from both sources as they arrive. + /// or is . + public IObservable Merge(IObservable second) + { + ArgumentExceptionHelper.ThrowIfNull(source); + + ArgumentExceptionHelper.ThrowIfNull(second); + + return new[] { source, second }.Blend(); } /// Concatenates two sequences. System.Reactive name for Chain. @@ -509,6 +739,14 @@ public IObservable Select(Func selector) return new MapSignal(source, selector); } + /// Projects each element and its zero-based index into a new form. LINQ name for MapIndexed. + /// The type of the elements in the result sequence. + /// A transform function to apply to each element and its index. + /// An observable sequence whose elements are the result of invoking the transform on each source element and index. + /// or is . + public IObservable Select(Func selector) => + source.MapIndexed(selector); + /// Projects each element into a new form using external state passed to the selector. State-carrying name for MapWith. /// The type of the state used in the selector function. /// The type of the elements in the result sequence. @@ -553,4 +791,20 @@ public IObservable WhereWith(TState state, Func(source, state, predicate); } } + + /// System.Reactive-named combining operators for an observable source of tasks. + /// The outer sequence of task sources. + /// The task result type. + extension(IObservable> sources) + { + /// Subscribes to task results one at a time in source order. System.Reactive name for Chain. + /// A sequence that emits each task result after the previous task signal completes. + /// is . + public IObservable Concat() + { + ArgumentExceptionHelper.ThrowIfNull(sources); + + return new TaskChainSignal(sources); + } + } } diff --git a/src/Primitives.Shared/SignalOperatorParityMixins.cs b/src/Primitives.Shared/SignalOperatorParityMixins.cs index e9f0e478..f03e7c30 100644 --- a/src/Primitives.Shared/SignalOperatorParityMixins.cs +++ b/src/Primitives.Shared/SignalOperatorParityMixins.cs @@ -21,6 +21,30 @@ public static partial class LinqExtensions /// The receiver sequence is . public IObservable ToObservable() => Signal.FromEnumerable(values); + /// Converts an enumerable sequence to a Primitives signal on the supplied scheduler. + /// The scheduler used to enumerate and emit the values. + /// A signal that emits the enumerable values on the supplied scheduler. + /// The receiver sequence or is . + public IObservable ToObservable(ISequencer scheduler) + { + ArgumentExceptionHelper.ThrowIfNull(values); + + ArgumentExceptionHelper.ThrowIfNull(scheduler); + + if (scheduler == Sequencer.Immediate || scheduler == Sequencer.CurrentThread) + { + return Signal.FromEnumerable(values); + } + + return Signal.Create(observer => + { + CancellationDisposable cancel = new(); + var scheduled = scheduler.Schedule(() => EmitEnumerable(values, observer, cancel)); + + return new MultipleDisposable(cancel, scheduled); + }); + } + /// Converts an enumerable sequence to a Primitives signal using the System.Reactive conversion name. /// The token used to stop enumeration. /// A signal that emits the enumerable values until enumeration completes or cancellation is requested. @@ -952,6 +976,11 @@ private Task FirstOrDefaultCoreAsync(bool hasDefault, T defaultValue) /// The task result type. extension(Task task) { + /// Converts a task to an observable sequence that emits the task result. + /// An observable sequence that emits the completed task result or faults with the task error. + /// The receiver task is . + public IObservable ToObservable() => Signal.FromTask(task); + /// Identity helper that keeps source-compatible FirstAsync().ToTask() migrations compiling. /// The supplied task. /// The receiver task is . @@ -959,6 +988,34 @@ private Task FirstOrDefaultCoreAsync(bool hasDefault, T defaultValue) public Task ToTask() => task ?? throw new ArgumentNullException(nameof(task)); } + /// Emits enumerable values while honoring a scheduled subscription cancellation. + /// The values to emit. + /// The destination observer. + /// The subscription cancellation. + /// The value type. + private static void EmitEnumerable( + IEnumerable values, + IObserver observer, + CancellationDisposable cancel) + { + foreach (var value in values) + { + if (cancel.IsDisposed) + { + return; + } + + observer.OnNext(value); + } + + if (cancel.IsDisposed) + { + return; + } + + observer.OnCompleted(); + } + /// Returns the final value as a completed task when the source is a readable range, avoiding a subscription. /// The value type. /// The source sequence. diff --git a/src/Primitives.Shared/Signals/SignalExtensions{Recover}.cs b/src/Primitives.Shared/Signals/SignalExtensions{Recover}.cs index e2047aa4..34e28a49 100644 --- a/src/Primitives.Shared/Signals/SignalExtensions{Recover}.cs +++ b/src/Primitives.Shared/Signals/SignalExtensions{Recover}.cs @@ -54,7 +54,13 @@ public IObservable Recover(FuncFinallies the specified finally action. /// The finally action. /// An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. - public IObservable OnCleanup(Action finallyAction) => - new FinallySignal(source, finallyAction); + public IObservable OnCleanup(Action finallyAction) + { + ArgumentExceptionHelper.ThrowIfNull(source); + + ArgumentExceptionHelper.ThrowIfNull(finallyAction); + + return new FinallySignal(source, finallyAction); + } } } diff --git a/src/Primitives.Shared/Signals/Signal{Create}.cs b/src/Primitives.Shared/Signals/Signal{Create}.cs index 3766dfa8..c0958e1c 100644 --- a/src/Primitives.Shared/Signals/Signal{Create}.cs +++ b/src/Primitives.Shared/Signals/Signal{Create}.cs @@ -3,8 +3,12 @@ // See the LICENSE file in the project root for full license information. #if REACTIVE_SHIM +using ReactiveUI.Primitives.Reactive.Advanced; + namespace ReactiveUI.Primitives.Reactive.Signals; #else +using ReactiveUI.Primitives.Advanced; + namespace ReactiveUI.Primitives.Signals; #endif @@ -27,6 +31,35 @@ public static IObservable Create(Func, IDisposable> subscribe return new CreateSignal(subscribe); } + /// Creates an observable from an asynchronous subscription function. + /// The type. + /// The asynchronous subscription function. + /// An observable sequence backed by the asynchronous subscription. + /// is . + public static IObservable Create(Func, Task> subscribe) + { + ArgumentExceptionHelper.ThrowIfNull(subscribe); + + return Create((observer, _) => subscribe(observer)); + } + + /// Creates an observable from a cancellable asynchronous subscription function. + /// The type. + /// The asynchronous subscription function. + /// An observable sequence backed by the asynchronous subscription. + /// is . + public static IObservable Create(Func, CancellationToken, Task> subscribe) + { + ArgumentExceptionHelper.ThrowIfNull(subscribe); + + return Create(observer => + { + AsyncSubscriptionLifetime subscription = new(); + _ = RunAsyncSubscription(subscribe, observer, subscription); + return subscription; + }); + } + /// /// Create anonymous Signals. Observer has exception durability. /// This is recommended for make operator and event, generating a HotSignals. @@ -150,4 +183,89 @@ public static IObservable Defer(Func> observableFactory) return source.Subscribe(observer); }); } + + /// Creates a signal whose source is produced asynchronously for each subscription. + /// The value type. + /// The asynchronous factory that creates the source signal for a subscription. + /// A signal that subscribes to the factory-produced source for each observer. + /// is . + public static IObservable Defer(Func>> observableFactory) + { + ArgumentExceptionHelper.ThrowIfNull(observableFactory); + + return Create( + async (observer, cancellationToken) => + { + IObservable source; + try + { + source = await observableFactory().ConfigureAwait(false); + } + catch (Exception error) + { + observer.OnError(error); + return EmptyDisposable.Instance; + } + + return cancellationToken.IsCancellationRequested ? EmptyDisposable.Instance : source.Subscribe(observer); + }); + } + + /// Creates a signal whose source is produced asynchronously for each subscription. + /// The value type. + /// The asynchronous factory that creates the source signal for a subscription. + /// A signal that subscribes to the factory-produced source for each observer. + /// is . + public static IObservable Defer(Func>> observableFactory) + { + ArgumentExceptionHelper.ThrowIfNull(observableFactory); + + return Create( + async (observer, cancellationToken) => + { + IObservable source; + try + { + source = await observableFactory(cancellationToken).ConfigureAwait(false); + } + catch (Exception error) + { + observer.OnError(error); + return EmptyDisposable.Instance; + } + + return cancellationToken.IsCancellationRequested ? EmptyDisposable.Instance : source.Subscribe(observer); + }); + } + + /// Completes an asynchronous subscription and assigns its disposable lifetime. + /// The value type. + /// The asynchronous subscription function. + /// The downstream observer. + /// The subscription slot. + /// A task that completes when the asynchronous subscription has assigned its disposable. + private static async Task RunAsyncSubscription( + Func, CancellationToken, Task> subscribe, + IObserver observer, + AsyncSubscriptionLifetime subscription) + { + try + { + var disposable = await subscribe(observer, subscription.Token).ConfigureAwait(false); + subscription.SetSubscription(disposable); + } + catch (OperationCanceledException) when (subscription.IsCancellationRequested) + { + subscription.SetSubscription(EmptyDisposable.Instance); + } + catch (Exception error) + { + observer.OnError(error); + subscription.SetSubscription(EmptyDisposable.Instance); + } + finally + { + subscription.Complete(); + } + } } diff --git a/src/Primitives.Shared/Signals/Signal{Factories}.cs b/src/Primitives.Shared/Signals/Signal{Factories}.cs index 21a41781..6f06aa18 100644 --- a/src/Primitives.Shared/Signals/Signal{Factories}.cs +++ b/src/Primitives.Shared/Signals/Signal{Factories}.cs @@ -2,6 +2,7 @@ // ReactiveUI Association Incorporated licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. +using System.Collections.Specialized; using System.ComponentModel; #if REACTIVE_SHIM @@ -209,6 +210,18 @@ public static IObservable> FromEventPattern + observer.OnNext(new(sender, (TEventArgs)(EventArgs)args)); + handler = (TEventHandler)(object)typed; + } + else if (typeof(TEventHandler) == typeof(ListChangedEventHandler)) + { + ListChangedEventHandler typed = (sender, args) => + observer.OnNext(new(sender, (TEventArgs)(EventArgs)args)); + handler = (TEventHandler)(object)typed; + } else if (typeof(TEventHandler) == typeof(EventHandler)) { EventHandler typed = (sender, args) => diff --git a/src/Primitives.Shared/Signals/Signal{RxAliases}.cs b/src/Primitives.Shared/Signals/Signal{RxAliases}.cs new file mode 100644 index 00000000..0a7e00b2 --- /dev/null +++ b/src/Primitives.Shared/Signals/Signal{RxAliases}.cs @@ -0,0 +1,169 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +#if REACTIVE_SHIM +namespace ReactiveUI.Primitives.Reactive.Signals; +#else +namespace ReactiveUI.Primitives.Signals; +#endif + +/// System.Reactive factory aliases for the Primitives signal factory vocabulary. +public static partial class Signal +{ + /// Returns an observable sequence that contains a single value. + /// The value type. + /// The value to emit. + /// An observable sequence that emits and completes. + public static IObservable Return(T value) => Emit(value); + + /// Returns an observable sequence that contains a single scheduled value. + /// The value type. + /// The value to emit. + /// The scheduler used to emit the value. + /// An observable sequence that emits and completes. + public static IObservable Return(T value, ISequencer scheduler) => Emit(value, scheduler); + + /// Returns an empty observable sequence. + /// The value type. + /// An observable sequence that completes without values. + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Major Code Smell", + "S4018:Generic methods should provide type parameters", + Justification = "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")] + public static IObservable Empty() => None(); + + /// Returns an empty observable sequence on the supplied scheduler. + /// The value type. + /// The scheduler used to complete the sequence. + /// An observable sequence that completes without values. + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Major Code Smell", + "S4018:Generic methods should provide type parameters", + Justification = "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")] + public static IObservable Empty(ISequencer scheduler) => None(scheduler); + + /// Returns a non-terminating observable sequence. + /// The value type. + /// An observable sequence that never emits and never terminates. + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Major Code Smell", + "S4018:Generic methods should provide type parameters", + Justification = "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")] + public static IObservable Never() => Silent(); + + /// Returns an observable sequence that terminates with an error. + /// The value type. + /// The error used to terminate the sequence. + /// An observable sequence that terminates with . + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Major Code Smell", + "S4018:Generic methods should provide type parameters", + Justification = "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")] + public static IObservable Throw(Exception error) => Fail(error); + + /// Returns an observable sequence that terminates with a scheduled error. + /// The value type. + /// The error used to terminate the sequence. + /// The scheduler used to emit the error. + /// An observable sequence that terminates with . + [System.Diagnostics.CodeAnalysis.SuppressMessage( + "Major Code Smell", + "S4018:Generic methods should provide type parameters", + Justification = "The type parameter defines the element type for this Rx-style factory and cannot be inferred from the arguments.")] + public static IObservable Throw(Exception error, ISequencer scheduler) => Fail(error, scheduler); + + /// Returns an observable sequence that emits a range of integral values. + /// The first value to emit. + /// The number of values to emit. + /// An observable sequence that emits the requested range and completes. + public static IObservable Range(int start, int count) => Sequence(start, count); + + /// Returns an observable sequence that emits a scheduled range of integral values. + /// The first value to emit. + /// The number of values to emit. + /// The scheduler used to emit the values. + /// An observable sequence that emits the requested range and completes. + public static IObservable Range(int start, int count, ISequencer scheduler) => Sequence(start, count, scheduler); + + /// Returns an observable sequence that emits a single tick after the due time. + /// The relative time after which to emit the tick. + /// An observable sequence that emits one tick and completes. + public static IObservable Timer(TimeSpan dueTime) => After(dueTime); + + /// Returns an observable sequence that emits a single tick after the due time on a scheduler. + /// The relative time after which to emit the tick. + /// The scheduler used to emit the tick. + /// An observable sequence that emits one tick and completes. + public static IObservable Timer(TimeSpan dueTime, ISequencer scheduler) => After(dueTime, scheduler); + + /// Returns an observable sequence that emits a single tick at an absolute due time. + /// The absolute time at which to emit the tick. + /// An observable sequence that emits one tick and completes. + public static IObservable Timer(DateTimeOffset dueTime) => After(dueTime); + + /// Returns an observable sequence that emits a single tick at an absolute due time on a scheduler. + /// The absolute time at which to emit the tick. + /// The scheduler used to emit the tick. + /// An observable sequence that emits one tick and completes. + public static IObservable Timer(DateTimeOffset dueTime, ISequencer scheduler) => After(dueTime, scheduler); + + /// Returns an observable sequence that emits ticks periodically after an initial due time. + /// The relative time before the first tick. + /// The period between subsequent ticks. + /// An observable sequence that emits periodic ticks. + public static IObservable Timer(TimeSpan dueTime, TimeSpan period) => After(dueTime, period); + + /// Returns an observable sequence that emits scheduled ticks periodically after an initial due time. + /// The relative time before the first tick. + /// The period between subsequent ticks. + /// The scheduler used to emit ticks. + /// An observable sequence that emits periodic ticks. + public static IObservable Timer(TimeSpan dueTime, TimeSpan period, ISequencer scheduler) => After(dueTime, period, scheduler); + + /// Returns an observable sequence that emits monotonically increasing ticks at the specified interval. + /// The period between ticks. + /// An observable sequence that emits periodic ticks. + public static IObservable Interval(TimeSpan period) => Every(period); + + /// Returns an observable sequence that emits scheduled, monotonically increasing ticks at the specified interval. + /// The period between ticks. + /// The scheduler used to emit ticks. + /// An observable sequence that emits periodic ticks. + public static IObservable Interval(TimeSpan period, ISequencer scheduler) => Every(period, scheduler); + + /// Concatenates the supplied observable sources. + /// The value type. + /// The sources to concatenate. + /// An observable sequence that subscribes to each source after the previous one completes. + public static IObservable Concat(params IObservable[] sources) => Chain(sources); + + /// Concatenates the supplied observable sources. + /// The value type. + /// The sources to concatenate. + /// An observable sequence that subscribes to each source after the previous one completes. + public static IObservable Concat(IEnumerable> sources) + { + ArgumentExceptionHelper.ThrowIfNull(sources); + + return FromEnumerable(sources).Chain(); + } + + /// Merges the supplied observable sources. + /// The value type. + /// The sources to merge. + /// An observable sequence that forwards values from every source. + public static IObservable Merge(params IObservable[] sources) => Blend(sources); + + /// Merges the supplied observable sources. + /// The value type. + /// The sources to merge. + /// An observable sequence that forwards values from every source. + public static IObservable Merge(IEnumerable> sources) => sources.Blend(); + + /// Switches to the most recent inner observable sequence. + /// The value type. + /// The outer sequence of inner sources. + /// An observable sequence that mirrors the latest inner source. + public static IObservable Switch(IObservable> sources) => sources.SwitchTo(); +} diff --git a/src/ReactiveUI.Primitives.Core/ConnectableSignal{T}.cs b/src/ReactiveUI.Primitives.Core/ConnectableSignal{T}.cs index 621108c9..b4851f17 100644 --- a/src/ReactiveUI.Primitives.Core/ConnectableSignal{T}.cs +++ b/src/ReactiveUI.Primitives.Core/ConnectableSignal{T}.cs @@ -2,6 +2,8 @@ // ReactiveUI Association Incorporated licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. +using System.Runtime.CompilerServices; +using ReactiveUI.Primitives.Disposables; using ReactiveUI.Primitives.Signals; namespace ReactiveUI.Primitives; @@ -20,8 +22,11 @@ public sealed class ConnectableSignal : IObservable /// Multicast hub that receives source values. private readonly ISignal _hub; - /// Active source connection. - private IDisposable? _connection; + /// Active source connection slot. The returned connection handle owns disposal. + private StrongBox? _connection; + + /// Set after the source sends a terminal notification to the hub. + private bool _terminated; /// Initializes a new instance of the class. /// The cold or hot source sequence. @@ -35,6 +40,7 @@ public ConnectableSignal(IObservable source, ISignal hub) /// Gets the debugger display text. [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage] private string DebuggerDisplay => ToString() ?? string.Empty; /// Subscribes the hub to the source if it is not already connected. @@ -43,17 +49,63 @@ public IDisposable Connect() { lock (_gate) { + if (Volatile.Read(ref _terminated)) + { + return Scope.Empty; + } + // Allocate the connection only on the first connect. A dedicated disposable type // avoids the closure (and extra anonymous-disposable wrapper) that Scope.Create // would allocate. - _connection ??= new Connection(this, _source.Subscribe(_hub)); - return _connection; + if (_connection?.Value is { } activeConnection) + { + return activeConnection; + } + + var sourceSubscription = _source.Subscribe(new ConnectionObserver(this)); + if (Volatile.Read(ref _terminated)) + { + sourceSubscription.Dispose(); + return Scope.Empty; + } + + var connection = new Connection(this, sourceSubscription); + _connection = new StrongBox(connection); + return connection; } } /// public IDisposable Subscribe(IObserver observer) => _hub.Subscribe(observer); + /// Forwards source notifications to the hub and latches terminal state. + private sealed class ConnectionObserver : IObserver + { + /// The owning connectable signal. + private readonly ConnectableSignal _parent; + + /// Initializes a new instance of the class. + /// The owning connectable signal. + public ConnectionObserver(ConnectableSignal parent) => _parent = parent; + + /// + public void OnCompleted() + { + Volatile.Write(ref _parent._terminated, true); + _parent._hub.OnCompleted(); + } + + /// + public void OnError(Exception error) + { + Volatile.Write(ref _parent._terminated, true); + _parent._hub.OnError(error); + } + + /// + public void OnNext(T value) => _parent._hub.OnNext(value); + } + /// Disconnect handle for an active source connection. private sealed class Connection : IDisposable { @@ -84,7 +136,7 @@ public void Dispose() lock (_parent._gate) { sourceSubscription.Dispose(); - if (ReferenceEquals(_parent._connection, this)) + if (_parent._connection is { Value: var activeConnection } && ReferenceEquals(activeConnection, this)) { _parent._connection = null; } diff --git a/src/ReactiveUI.Primitives.Core/Optional.Factory.cs b/src/ReactiveUI.Primitives.Core/Optional.Factory.cs new file mode 100644 index 00000000..473a4b0b --- /dev/null +++ b/src/ReactiveUI.Primitives.Core/Optional.Factory.cs @@ -0,0 +1,17 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Diagnostics.CodeAnalysis; + +namespace ReactiveUI.Primitives; + +/// Provides factory helpers for optional values. +public static class Optional +{ + /// Wraps the specified value in an optional container. + /// The type of the optional value. + /// The value to wrap. + /// The optional value. + public static Optional Some([AllowNull] T value) => Optional.Some(value); +} diff --git a/src/ReactiveUI.Primitives.Core/Optional.cs b/src/ReactiveUI.Primitives.Core/Optional.cs index bbc1fe6d..1b62c4b7 100644 --- a/src/ReactiveUI.Primitives.Core/Optional.cs +++ b/src/ReactiveUI.Primitives.Core/Optional.cs @@ -2,6 +2,8 @@ // ReactiveUI Association Incorporated licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. +using System.Diagnostics.CodeAnalysis; + namespace ReactiveUI.Primitives; /// Represents an optional value that may or may not be present. @@ -24,12 +26,12 @@ public readonly record struct Optional /// Initializes a new instance of the struct. /// The value to be contained in the instance. - public Optional(T value) => (_value, HasValue) = (value, true); + public Optional([AllowNull] T value) => (_value, HasValue) = value is null ? (default, false) : (value, true); /// Initializes a new instance of the struct. /// The value. /// A value indicating whether a value is present. - private Optional(T value, bool hasValue) => (_value, HasValue) = (value, hasValue); + private Optional([AllowNull] T value, bool hasValue) => (_value, HasValue) = hasValue && value is not null ? (value, true) : (default, false); /// Gets an empty instance of the type that contains no value. /// Use this property to represent the absence of a value in a type-safe manner. The returned @@ -46,19 +48,20 @@ public readonly record struct Optional /// Accessing this property when the optional object does not have a value will throw an /// exception. Use the HasValue property to determine whether a value is present before accessing this /// property. + [NotNull] public T? Value => HasValue - ? _value + ? _value! : throw new InvalidOperationException("Impossible retrieve a value for an empty optional"); /// Creates an optional value containing a value. /// The contained value. /// The optional value. - public static Optional Some(T value) => new(value, hasValue: true); + public static Optional Some([AllowNull] T value) => new(value, hasValue: true); /// Implicit cast from the value to the optional. /// The value. /// The optional value. - public static implicit operator Optional(T value) => ToOptional(value); + public static implicit operator Optional([AllowNull] T value) => ToOptional(value); /// Explicit cast from option to value. /// The value. @@ -68,7 +71,7 @@ public readonly record struct Optional /// Creates the specified value. /// The value. /// The optional value. - public static Optional Create(T value) => new(value); + public static Optional Create([AllowNull] T value) => new(value); /// Gets the value from the optional value. /// The optional value. @@ -78,7 +81,7 @@ public readonly record struct Optional /// Gets the optional from a value. /// The value to get the optional for. /// The optional. - public static Optional ToOptional(T value) => new(value); + public static Optional ToOptional([AllowNull] T value) => new(value); /// public override string? ToString() diff --git a/src/ReactiveUI.Primitives.Core/PublicAPI/net10.0/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Core/PublicAPI/net10.0/PublicAPI.Unshipped.txt index 7dc5c581..da6f2859 100644 --- a/src/ReactiveUI.Primitives.Core/PublicAPI/net10.0/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Core/PublicAPI/net10.0/PublicAPI.Unshipped.txt @@ -1 +1,3 @@ #nullable enable +ReactiveUI.Primitives.Optional +static ReactiveUI.Primitives.Optional.Some(T value) -> ReactiveUI.Primitives.Optional diff --git a/src/ReactiveUI.Primitives.Core/PublicAPI/net11.0/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Core/PublicAPI/net11.0/PublicAPI.Unshipped.txt index 7dc5c581..da6f2859 100644 --- a/src/ReactiveUI.Primitives.Core/PublicAPI/net11.0/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Core/PublicAPI/net11.0/PublicAPI.Unshipped.txt @@ -1 +1,3 @@ #nullable enable +ReactiveUI.Primitives.Optional +static ReactiveUI.Primitives.Optional.Some(T value) -> ReactiveUI.Primitives.Optional diff --git a/src/ReactiveUI.Primitives.Core/PublicAPI/net462/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Core/PublicAPI/net462/PublicAPI.Unshipped.txt index 7dc5c581..da6f2859 100644 --- a/src/ReactiveUI.Primitives.Core/PublicAPI/net462/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Core/PublicAPI/net462/PublicAPI.Unshipped.txt @@ -1 +1,3 @@ #nullable enable +ReactiveUI.Primitives.Optional +static ReactiveUI.Primitives.Optional.Some(T value) -> ReactiveUI.Primitives.Optional diff --git a/src/ReactiveUI.Primitives.Core/PublicAPI/net472/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Core/PublicAPI/net472/PublicAPI.Unshipped.txt index 7dc5c581..da6f2859 100644 --- a/src/ReactiveUI.Primitives.Core/PublicAPI/net472/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Core/PublicAPI/net472/PublicAPI.Unshipped.txt @@ -1 +1,3 @@ #nullable enable +ReactiveUI.Primitives.Optional +static ReactiveUI.Primitives.Optional.Some(T value) -> ReactiveUI.Primitives.Optional diff --git a/src/ReactiveUI.Primitives.Core/PublicAPI/net48/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Core/PublicAPI/net48/PublicAPI.Unshipped.txt index 7dc5c581..da6f2859 100644 --- a/src/ReactiveUI.Primitives.Core/PublicAPI/net48/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Core/PublicAPI/net48/PublicAPI.Unshipped.txt @@ -1 +1,3 @@ #nullable enable +ReactiveUI.Primitives.Optional +static ReactiveUI.Primitives.Optional.Some(T value) -> ReactiveUI.Primitives.Optional diff --git a/src/ReactiveUI.Primitives.Core/PublicAPI/net481/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Core/PublicAPI/net481/PublicAPI.Unshipped.txt index 7dc5c581..da6f2859 100644 --- a/src/ReactiveUI.Primitives.Core/PublicAPI/net481/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Core/PublicAPI/net481/PublicAPI.Unshipped.txt @@ -1 +1,3 @@ #nullable enable +ReactiveUI.Primitives.Optional +static ReactiveUI.Primitives.Optional.Some(T value) -> ReactiveUI.Primitives.Optional diff --git a/src/ReactiveUI.Primitives.Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt index 7dc5c581..da6f2859 100644 --- a/src/ReactiveUI.Primitives.Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt @@ -1 +1,3 @@ #nullable enable +ReactiveUI.Primitives.Optional +static ReactiveUI.Primitives.Optional.Some(T value) -> ReactiveUI.Primitives.Optional diff --git a/src/ReactiveUI.Primitives.Core/PublicAPI/net9.0/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Core/PublicAPI/net9.0/PublicAPI.Unshipped.txt index 7dc5c581..da6f2859 100644 --- a/src/ReactiveUI.Primitives.Core/PublicAPI/net9.0/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Core/PublicAPI/net9.0/PublicAPI.Unshipped.txt @@ -1 +1,3 @@ #nullable enable +ReactiveUI.Primitives.Optional +static ReactiveUI.Primitives.Optional.Some(T value) -> ReactiveUI.Primitives.Optional diff --git a/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs b/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs index 596c022e..ef21a0d7 100644 --- a/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs +++ b/src/ReactiveUI.Primitives.Core/Signals/Signal{T}.cs @@ -124,21 +124,36 @@ public void OnError(Exception error) /// The value. public void OnNext(T value) { - var singleObserver = Volatile.Read(ref _singleObserverSubscription); + SignalSubscription? singleObserver; + SignalSubscription? singleAction; + SignalSubscription?[]? subscriptions; + + lock (_observerLock) + { + ThrowIfDisposed(); + if (_isStopped) + { + return; + } + + singleObserver = _singleObserverSubscription; + singleAction = _singleActionSubscription; + subscriptions = _subscriptions; + } + if (singleObserver is not null) { singleObserver.Observer.OnNext(value); return; } - var singleAction = Volatile.Read(ref _singleActionSubscription); if (singleAction is not null) { singleAction.Action(value); return; } - DispatchSubscriptions(value); + DispatchSubscriptions(subscriptions, value); if (!Volatile.Read(ref _isDisposed)) { return; @@ -350,6 +365,28 @@ private static void DisposeSubscriptions(SignalSubscription?[]? subscriptions) } } + /// Executes the DispatchSubscriptions operation. + /// The subscription snapshot. + /// The value. + private static void DispatchSubscriptions(SignalSubscription?[]? subscriptions, T value) + { + if (subscriptions is null) + { + return; + } + + for (var i = 0; i < subscriptions.Length; i++) + { + var subscription = Volatile.Read(ref subscriptions[i]); + if (subscription is null) + { + continue; + } + + subscription.OnNext(value); + } + } + /// Executes the ThrowIfDisposed operation. private void ThrowIfDisposed() { @@ -500,28 +537,6 @@ private void RemoveArraySubscriptionLocked(SignalSubscription subscription) } } - /// Executes the DispatchSubscriptions operation. - /// The value. - private void DispatchSubscriptions(T value) - { - var subscriptions = Volatile.Read(ref _subscriptions); - if (subscriptions is null) - { - return; - } - - for (var i = 0; i < subscriptions.Length; i++) - { - var subscription = Volatile.Read(ref subscriptions[i]); - if (subscription is null) - { - continue; - } - - subscription.OnNext(value); - } - } - /// Represents the SignalSubscription class. private sealed class SignalSubscription : IDisposable { diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-android/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-android/PublicAPI.Shipped.txt index cbfea4a8..9699eabb 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-android/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-android/PublicAPI.Shipped.txt @@ -41,10 +41,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -74,8 +79,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -91,6 +100,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -103,8 +115,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -150,9 +165,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -175,7 +192,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -191,7 +210,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -199,7 +220,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -217,12 +245,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -242,6 +274,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -261,6 +295,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -351,8 +386,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -376,15 +416,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -407,6 +452,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -439,9 +485,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -466,9 +514,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -488,8 +540,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -498,7 +553,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -519,12 +581,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -536,10 +602,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -561,13 +630,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -575,6 +650,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -599,10 +676,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -612,7 +694,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -623,7 +709,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-android/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-android/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-android/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-android/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-ios/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-ios/PublicAPI.Shipped.txt index 4a4d5a16..3dbb2eab 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-ios/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-ios/PublicAPI.Shipped.txt @@ -39,10 +39,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -72,8 +77,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -89,6 +98,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -101,8 +113,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -148,9 +163,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -173,7 +190,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -189,7 +208,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -197,7 +218,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -215,12 +243,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -240,6 +272,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -259,6 +293,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -347,8 +382,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -372,15 +412,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -403,6 +448,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -435,9 +481,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -462,9 +510,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -484,8 +536,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -494,7 +549,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -515,12 +577,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -532,10 +598,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -557,13 +626,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -571,6 +646,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -595,10 +672,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -608,7 +690,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -619,7 +705,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-ios/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-ios/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-ios/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-ios/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-maccatalyst/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-maccatalyst/PublicAPI.Shipped.txt index 4a4d5a16..3dbb2eab 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-maccatalyst/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-maccatalyst/PublicAPI.Shipped.txt @@ -39,10 +39,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -72,8 +77,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -89,6 +98,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -101,8 +113,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -148,9 +163,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -173,7 +190,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -189,7 +208,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -197,7 +218,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -215,12 +243,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -240,6 +272,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -259,6 +293,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -347,8 +382,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -372,15 +412,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -403,6 +448,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -435,9 +481,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -462,9 +510,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -484,8 +536,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -494,7 +549,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -515,12 +577,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -532,10 +598,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -557,13 +626,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -571,6 +646,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -595,10 +672,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -608,7 +690,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -619,7 +705,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-maccatalyst/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-maccatalyst/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-maccatalyst/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-maccatalyst/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-macos/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-macos/PublicAPI.Shipped.txt index 4a4d5a16..3dbb2eab 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-macos/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-macos/PublicAPI.Shipped.txt @@ -39,10 +39,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -72,8 +77,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -89,6 +98,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -101,8 +113,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -148,9 +163,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -173,7 +190,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -189,7 +208,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -197,7 +218,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -215,12 +243,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -240,6 +272,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -259,6 +293,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -347,8 +382,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -372,15 +412,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -403,6 +448,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -435,9 +481,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -462,9 +510,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -484,8 +536,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -494,7 +549,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -515,12 +577,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -532,10 +598,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -557,13 +626,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -571,6 +646,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -595,10 +672,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -608,7 +690,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -619,7 +705,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-macos/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-macos/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-macos/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-macos/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-tvos/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-tvos/PublicAPI.Shipped.txt index 4a4d5a16..3dbb2eab 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-tvos/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-tvos/PublicAPI.Shipped.txt @@ -39,10 +39,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -72,8 +77,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -89,6 +98,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -101,8 +113,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -148,9 +163,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -173,7 +190,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -189,7 +208,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -197,7 +218,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -215,12 +243,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -240,6 +272,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -259,6 +293,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -347,8 +382,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -372,15 +412,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -403,6 +448,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -435,9 +481,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -462,9 +510,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -484,8 +536,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -494,7 +549,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -515,12 +577,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -532,10 +598,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -557,13 +626,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -571,6 +646,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -595,10 +672,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -608,7 +690,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -619,7 +705,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-tvos/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-tvos/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-tvos/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0-tvos/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0/PublicAPI.Shipped.txt index b3926eb2..923bba12 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0/PublicAPI.Shipped.txt @@ -35,10 +35,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -68,8 +73,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -85,6 +94,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -97,8 +109,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -144,9 +159,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -169,7 +186,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -185,7 +204,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -193,7 +214,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -211,12 +239,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -236,6 +268,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -255,6 +289,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -338,8 +373,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -363,15 +403,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -394,6 +439,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -426,9 +472,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -453,9 +501,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -475,8 +527,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -485,7 +540,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -506,12 +568,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -523,10 +589,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -548,13 +617,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -562,6 +637,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -586,10 +663,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -599,7 +681,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -610,7 +696,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net10.0/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-android/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-android/PublicAPI.Shipped.txt index cbfea4a8..9699eabb 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-android/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-android/PublicAPI.Shipped.txt @@ -41,10 +41,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -74,8 +79,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -91,6 +100,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -103,8 +115,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -150,9 +165,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -175,7 +192,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -191,7 +210,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -199,7 +220,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -217,12 +245,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -242,6 +274,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -261,6 +295,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -351,8 +386,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -376,15 +416,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -407,6 +452,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -439,9 +485,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -466,9 +514,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -488,8 +540,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -498,7 +553,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -519,12 +581,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -536,10 +602,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -561,13 +630,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -575,6 +650,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -599,10 +676,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -612,7 +694,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -623,7 +709,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-android/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-android/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-android/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-android/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-ios/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-ios/PublicAPI.Shipped.txt index 4a4d5a16..3dbb2eab 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-ios/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-ios/PublicAPI.Shipped.txt @@ -39,10 +39,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -72,8 +77,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -89,6 +98,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -101,8 +113,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -148,9 +163,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -173,7 +190,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -189,7 +208,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -197,7 +218,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -215,12 +243,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -240,6 +272,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -259,6 +293,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -347,8 +382,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -372,15 +412,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -403,6 +448,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -435,9 +481,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -462,9 +510,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -484,8 +536,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -494,7 +549,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -515,12 +577,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -532,10 +598,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -557,13 +626,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -571,6 +646,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -595,10 +672,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -608,7 +690,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -619,7 +705,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-ios/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-ios/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-ios/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-ios/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-maccatalyst/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-maccatalyst/PublicAPI.Shipped.txt index 4a4d5a16..3dbb2eab 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-maccatalyst/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-maccatalyst/PublicAPI.Shipped.txt @@ -39,10 +39,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -72,8 +77,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -89,6 +98,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -101,8 +113,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -148,9 +163,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -173,7 +190,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -189,7 +208,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -197,7 +218,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -215,12 +243,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -240,6 +272,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -259,6 +293,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -347,8 +382,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -372,15 +412,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -403,6 +448,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -435,9 +481,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -462,9 +510,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -484,8 +536,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -494,7 +549,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -515,12 +577,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -532,10 +598,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -557,13 +626,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -571,6 +646,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -595,10 +672,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -608,7 +690,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -619,7 +705,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-maccatalyst/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-maccatalyst/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-maccatalyst/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-maccatalyst/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-macos/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-macos/PublicAPI.Shipped.txt index 4a4d5a16..3dbb2eab 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-macos/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-macos/PublicAPI.Shipped.txt @@ -39,10 +39,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -72,8 +77,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -89,6 +98,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -101,8 +113,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -148,9 +163,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -173,7 +190,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -189,7 +208,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -197,7 +218,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -215,12 +243,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -240,6 +272,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -259,6 +293,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -347,8 +382,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -372,15 +412,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -403,6 +448,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -435,9 +481,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -462,9 +510,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -484,8 +536,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -494,7 +549,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -515,12 +577,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -532,10 +598,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -557,13 +626,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -571,6 +646,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -595,10 +672,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -608,7 +690,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -619,7 +705,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-macos/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-macos/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-macos/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-macos/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-tvos/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-tvos/PublicAPI.Shipped.txt index 4a4d5a16..3dbb2eab 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-tvos/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-tvos/PublicAPI.Shipped.txt @@ -39,10 +39,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -72,8 +77,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -89,6 +98,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -101,8 +113,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -148,9 +163,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -173,7 +190,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -189,7 +208,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -197,7 +218,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -215,12 +243,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -240,6 +272,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -259,6 +293,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -347,8 +382,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -372,15 +412,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -403,6 +448,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -435,9 +481,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -462,9 +510,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -484,8 +536,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -494,7 +549,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -515,12 +577,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -532,10 +598,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -557,13 +626,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -571,6 +646,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -595,10 +672,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -608,7 +690,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -619,7 +705,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-tvos/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-tvos/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-tvos/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0-tvos/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0/PublicAPI.Shipped.txt index b3926eb2..923bba12 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0/PublicAPI.Shipped.txt @@ -35,10 +35,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -68,8 +73,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -85,6 +94,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -97,8 +109,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -144,9 +159,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -169,7 +186,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -185,7 +204,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -193,7 +214,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -211,12 +239,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -236,6 +268,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -255,6 +289,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -338,8 +373,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -363,15 +403,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -394,6 +439,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -426,9 +472,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -453,9 +501,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -475,8 +527,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -485,7 +540,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -506,12 +568,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -523,10 +589,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -548,13 +617,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -562,6 +637,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -586,10 +663,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -599,7 +681,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -610,7 +696,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net11.0/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net462/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net462/PublicAPI.Shipped.txt index f0e47865..ef1c5c40 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net462/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net462/PublicAPI.Shipped.txt @@ -35,10 +35,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -68,8 +73,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -85,6 +94,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -97,8 +109,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -144,9 +159,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -169,7 +186,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -185,7 +204,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -193,7 +214,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -211,12 +239,15 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -236,6 +267,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -255,6 +288,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -338,8 +372,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -363,15 +402,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -394,6 +438,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -426,9 +471,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -453,9 +500,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -475,8 +526,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -485,7 +539,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -506,12 +567,15 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -523,10 +587,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -548,13 +615,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -562,6 +635,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -584,10 +659,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -597,7 +677,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -608,7 +692,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net462/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net462/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net462/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net462/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net472/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net472/PublicAPI.Shipped.txt index f0e47865..ef1c5c40 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net472/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net472/PublicAPI.Shipped.txt @@ -35,10 +35,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -68,8 +73,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -85,6 +94,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -97,8 +109,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -144,9 +159,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -169,7 +186,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -185,7 +204,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -193,7 +214,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -211,12 +239,15 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -236,6 +267,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -255,6 +288,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -338,8 +372,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -363,15 +402,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -394,6 +438,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -426,9 +471,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -453,9 +500,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -475,8 +526,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -485,7 +539,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -506,12 +567,15 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -523,10 +587,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -548,13 +615,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -562,6 +635,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -584,10 +659,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -597,7 +677,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -608,7 +692,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net472/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net472/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net472/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net472/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net48/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net48/PublicAPI.Shipped.txt index f0e47865..ef1c5c40 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net48/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net48/PublicAPI.Shipped.txt @@ -35,10 +35,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -68,8 +73,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -85,6 +94,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -97,8 +109,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -144,9 +159,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -169,7 +186,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -185,7 +204,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -193,7 +214,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -211,12 +239,15 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -236,6 +267,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -255,6 +288,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -338,8 +372,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -363,15 +402,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -394,6 +438,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -426,9 +471,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -453,9 +500,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -475,8 +526,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -485,7 +539,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -506,12 +567,15 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -523,10 +587,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -548,13 +615,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -562,6 +635,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -584,10 +659,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -597,7 +677,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -608,7 +692,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net48/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net48/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net48/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net48/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net481/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net481/PublicAPI.Shipped.txt index f0e47865..ef1c5c40 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net481/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net481/PublicAPI.Shipped.txt @@ -35,10 +35,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -68,8 +73,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -85,6 +94,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -97,8 +109,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -144,9 +159,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -169,7 +186,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -185,7 +204,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -193,7 +214,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -211,12 +239,15 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -236,6 +267,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -255,6 +288,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -338,8 +372,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -363,15 +402,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -394,6 +438,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -426,9 +471,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -453,9 +500,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -475,8 +526,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -485,7 +539,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -506,12 +567,15 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -523,10 +587,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -548,13 +615,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -562,6 +635,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -584,10 +659,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -597,7 +677,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -608,7 +692,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net481/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net481/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net481/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net481/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net8.0/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net8.0/PublicAPI.Shipped.txt index 3b9d42fc..2702d54d 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net8.0/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net8.0/PublicAPI.Shipped.txt @@ -35,10 +35,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -68,8 +73,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -85,6 +94,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -97,8 +109,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -144,9 +159,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -169,7 +186,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -185,7 +204,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -193,7 +214,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -211,12 +239,15 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -236,6 +267,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -255,6 +288,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -338,8 +372,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -363,15 +402,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -394,6 +438,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -426,9 +471,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -453,9 +500,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -475,8 +526,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -485,7 +539,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -506,12 +567,15 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -523,10 +587,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -548,13 +615,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -562,6 +635,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -586,10 +661,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -599,7 +679,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -610,7 +694,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net8.0/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net8.0/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net8.0/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net9.0/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net9.0/PublicAPI.Shipped.txt index b3926eb2..923bba12 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net9.0/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net9.0/PublicAPI.Shipped.txt @@ -35,10 +35,15 @@ ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(Reactive ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -68,8 +73,12 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -85,6 +94,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -97,8 +109,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -144,9 +159,11 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -169,7 +186,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).ObserveOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -185,7 +204,9 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -193,7 +214,14 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeOn(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -211,12 +239,16 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).TimeInterval(System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -236,6 +268,8 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -255,6 +289,7 @@ ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObserva ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.Reactive.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -338,8 +373,13 @@ static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.Reactive.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -363,15 +403,20 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Append(this System.IObse static ReactiveUI.Primitives.Reactive.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -394,6 +439,7 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -426,9 +472,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.DistinctUntilChangedBy(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -453,9 +501,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Lead(this System.IObserv static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ObserveOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -475,8 +527,11 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.I static ReactiveUI.Primitives.Reactive.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! @@ -485,7 +540,14 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SkipWhile(this System.IO static ReactiveUI.Primitives.Reactive.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeOn(this System.IObservable! source, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -506,12 +568,16 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.TimeInterval(this System.IObservable! source, System.Reactive.Concurrency.IScheduler? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.Reactive.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -523,10 +589,13 @@ static ReactiveUI.Primitives.Reactive.LinqExtensions.ToArrayAsync(this System static ReactiveUI.Primitives.Reactive.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.Reactive.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -548,13 +617,19 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTi static ReactiveUI.Primitives.Reactive.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(System.Reactive.Unit value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -562,6 +637,8 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(int value) -> System.I static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Emit(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Empty(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Every(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -586,10 +663,15 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Threadin static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.FromTask(System.Func!>! actionAsync, System.Reactive.Concurrency.IScheduler? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Interval(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.None(System.Reactive.Concurrency.IScheduler! scheduler, T witness) -> System.IObservable! @@ -599,7 +681,11 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.PairLatest System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Pulse(System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Range(int start, int count, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Return(T value, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Scheduled(System.Reactive.Concurrency.IScheduler! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Reactive.Signals.ScheduledSignal! static ReactiveUI.Primitives.Reactive.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -610,7 +696,16 @@ static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Action! action, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Start(System.Func! function, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Throw(System.Exception! error, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.DateTimeOffset dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Reactive.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, System.Reactive.Concurrency.IScheduler! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Reactive.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net9.0/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net9.0/PublicAPI.Unshipped.txt index 7dc5c581..150d4b6f 100644 --- a/src/ReactiveUI.Primitives.Reactive/PublicAPI/net9.0/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives.Reactive/PublicAPI/net9.0/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Reactive.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Reactive.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Reactive.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Reactive.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Reactive.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-android/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-android/PublicAPI.Shipped.txt index 18fb0d78..eda0f215 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-android/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-android/PublicAPI.Shipped.txt @@ -149,10 +149,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -182,8 +187,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -199,6 +208,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -211,8 +223,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -258,9 +273,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -283,7 +300,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -299,7 +318,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -307,7 +328,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -325,12 +353,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -350,6 +382,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -369,6 +403,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -494,8 +529,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -519,15 +559,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -550,6 +595,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -582,9 +628,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -609,9 +657,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -631,8 +683,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -641,7 +696,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -662,12 +724,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -679,10 +745,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -707,13 +776,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -721,6 +796,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -745,10 +822,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -758,7 +840,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -769,7 +855,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-android/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-android/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-android/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-android/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-ios/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-ios/PublicAPI.Shipped.txt index 9f8e3079..9dea07e0 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-ios/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-ios/PublicAPI.Shipped.txt @@ -147,10 +147,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -180,8 +185,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -197,6 +206,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -209,8 +221,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -256,9 +271,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -281,7 +298,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -297,7 +316,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -305,7 +326,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -323,12 +351,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -348,6 +380,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -367,6 +401,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -490,8 +525,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -515,15 +555,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -546,6 +591,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -578,9 +624,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -605,9 +653,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -627,8 +679,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -637,7 +692,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -658,12 +720,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -675,10 +741,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -703,13 +772,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -717,6 +792,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -741,10 +818,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -754,7 +836,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -765,7 +851,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-ios/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-ios/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-ios/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-ios/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-maccatalyst/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-maccatalyst/PublicAPI.Shipped.txt index 9f8e3079..9dea07e0 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-maccatalyst/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-maccatalyst/PublicAPI.Shipped.txt @@ -147,10 +147,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -180,8 +185,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -197,6 +206,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -209,8 +221,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -256,9 +271,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -281,7 +298,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -297,7 +316,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -305,7 +326,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -323,12 +351,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -348,6 +380,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -367,6 +401,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -490,8 +525,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -515,15 +555,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -546,6 +591,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -578,9 +624,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -605,9 +653,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -627,8 +679,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -637,7 +692,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -658,12 +720,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -675,10 +741,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -703,13 +772,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -717,6 +792,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -741,10 +818,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -754,7 +836,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -765,7 +851,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-maccatalyst/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-maccatalyst/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-maccatalyst/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-maccatalyst/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-macos/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-macos/PublicAPI.Shipped.txt index 9f8e3079..9dea07e0 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-macos/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-macos/PublicAPI.Shipped.txt @@ -147,10 +147,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -180,8 +185,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -197,6 +206,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -209,8 +221,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -256,9 +271,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -281,7 +298,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -297,7 +316,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -305,7 +326,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -323,12 +351,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -348,6 +380,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -367,6 +401,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -490,8 +525,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -515,15 +555,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -546,6 +591,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -578,9 +624,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -605,9 +653,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -627,8 +679,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -637,7 +692,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -658,12 +720,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -675,10 +741,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -703,13 +772,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -717,6 +792,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -741,10 +818,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -754,7 +836,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -765,7 +851,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-macos/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-macos/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-macos/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-macos/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-tvos/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-tvos/PublicAPI.Shipped.txt index 9f8e3079..9dea07e0 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-tvos/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-tvos/PublicAPI.Shipped.txt @@ -147,10 +147,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -180,8 +185,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -197,6 +206,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -209,8 +221,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -256,9 +271,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -281,7 +298,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -297,7 +316,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -305,7 +326,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -323,12 +351,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -348,6 +380,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -367,6 +401,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -490,8 +525,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -515,15 +555,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -546,6 +591,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -578,9 +624,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -605,9 +653,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -627,8 +679,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -637,7 +692,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -658,12 +720,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -675,10 +741,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -703,13 +772,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -717,6 +792,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -741,10 +818,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -754,7 +836,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -765,7 +851,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0-tvos/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0-tvos/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net10.0-tvos/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0-tvos/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0/PublicAPI.Shipped.txt index 18ae7b29..b5d9b271 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net10.0/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0/PublicAPI.Shipped.txt @@ -142,10 +142,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -175,8 +180,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -192,6 +201,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -204,8 +216,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -251,9 +266,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -276,7 +293,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -292,7 +311,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -300,7 +321,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -318,12 +346,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -343,6 +375,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -362,6 +396,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -483,8 +518,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -508,15 +548,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -539,6 +584,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -571,9 +617,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -598,9 +646,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -620,8 +672,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -630,7 +685,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -651,12 +713,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -668,10 +734,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -696,13 +765,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -710,6 +785,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -734,10 +811,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -747,7 +829,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -758,7 +844,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net10.0/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net10.0/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net10.0/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net10.0/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-android/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-android/PublicAPI.Shipped.txt index 18fb0d78..eda0f215 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-android/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-android/PublicAPI.Shipped.txt @@ -149,10 +149,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -182,8 +187,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -199,6 +208,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -211,8 +223,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -258,9 +273,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -283,7 +300,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -299,7 +318,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -307,7 +328,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -325,12 +353,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -350,6 +382,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -369,6 +403,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -494,8 +529,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -519,15 +559,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -550,6 +595,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -582,9 +628,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -609,9 +657,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -631,8 +683,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -641,7 +696,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -662,12 +724,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -679,10 +745,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -707,13 +776,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -721,6 +796,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -745,10 +822,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -758,7 +840,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -769,7 +855,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-android/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-android/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-android/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-android/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-ios/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-ios/PublicAPI.Shipped.txt index 9f8e3079..9dea07e0 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-ios/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-ios/PublicAPI.Shipped.txt @@ -147,10 +147,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -180,8 +185,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -197,6 +206,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -209,8 +221,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -256,9 +271,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -281,7 +298,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -297,7 +316,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -305,7 +326,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -323,12 +351,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -348,6 +380,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -367,6 +401,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -490,8 +525,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -515,15 +555,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -546,6 +591,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -578,9 +624,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -605,9 +653,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -627,8 +679,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -637,7 +692,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -658,12 +720,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -675,10 +741,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -703,13 +772,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -717,6 +792,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -741,10 +818,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -754,7 +836,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -765,7 +851,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-ios/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-ios/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-ios/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-ios/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-maccatalyst/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-maccatalyst/PublicAPI.Shipped.txt index 9f8e3079..9dea07e0 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-maccatalyst/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-maccatalyst/PublicAPI.Shipped.txt @@ -147,10 +147,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -180,8 +185,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -197,6 +206,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -209,8 +221,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -256,9 +271,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -281,7 +298,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -297,7 +316,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -305,7 +326,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -323,12 +351,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -348,6 +380,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -367,6 +401,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -490,8 +525,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -515,15 +555,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -546,6 +591,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -578,9 +624,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -605,9 +653,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -627,8 +679,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -637,7 +692,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -658,12 +720,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -675,10 +741,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -703,13 +772,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -717,6 +792,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -741,10 +818,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -754,7 +836,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -765,7 +851,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-maccatalyst/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-maccatalyst/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-maccatalyst/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-maccatalyst/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-macos/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-macos/PublicAPI.Shipped.txt index 9f8e3079..9dea07e0 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-macos/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-macos/PublicAPI.Shipped.txt @@ -147,10 +147,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -180,8 +185,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -197,6 +206,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -209,8 +221,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -256,9 +271,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -281,7 +298,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -297,7 +316,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -305,7 +326,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -323,12 +351,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -348,6 +380,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -367,6 +401,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -490,8 +525,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -515,15 +555,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -546,6 +591,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -578,9 +624,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -605,9 +653,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -627,8 +679,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -637,7 +692,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -658,12 +720,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -675,10 +741,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -703,13 +772,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -717,6 +792,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -741,10 +818,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -754,7 +836,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -765,7 +851,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-macos/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-macos/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-macos/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-macos/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-tvos/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-tvos/PublicAPI.Shipped.txt index 9f8e3079..9dea07e0 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-tvos/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-tvos/PublicAPI.Shipped.txt @@ -147,10 +147,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -180,8 +185,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -197,6 +206,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -209,8 +221,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -256,9 +271,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -281,7 +298,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -297,7 +316,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -305,7 +326,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -323,12 +351,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -348,6 +380,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -367,6 +401,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -490,8 +525,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -515,15 +555,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -546,6 +591,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -578,9 +624,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -605,9 +653,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -627,8 +679,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -637,7 +692,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -658,12 +720,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -675,10 +741,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -703,13 +772,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -717,6 +792,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -741,10 +818,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -754,7 +836,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -765,7 +851,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0-tvos/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0-tvos/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net11.0-tvos/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0-tvos/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0/PublicAPI.Shipped.txt index 18ae7b29..b5d9b271 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net11.0/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0/PublicAPI.Shipped.txt @@ -142,10 +142,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -175,8 +180,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -192,6 +201,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -204,8 +216,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -251,9 +266,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -276,7 +293,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -292,7 +311,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -300,7 +321,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -318,12 +346,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -343,6 +375,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -362,6 +396,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -483,8 +518,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -508,15 +548,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -539,6 +584,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -571,9 +617,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -598,9 +646,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -620,8 +672,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -630,7 +685,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -651,12 +713,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -668,10 +734,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -696,13 +765,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -710,6 +785,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -734,10 +811,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -747,7 +829,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -758,7 +844,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net11.0/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net11.0/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net11.0/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net11.0/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net462/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net462/PublicAPI.Shipped.txt index 268d42ab..f09a77ad 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net462/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net462/PublicAPI.Shipped.txt @@ -142,10 +142,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -175,8 +180,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -192,6 +201,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -204,8 +216,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -251,9 +266,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -276,7 +293,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -292,7 +311,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -300,7 +321,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -318,12 +346,15 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -343,6 +374,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -362,6 +395,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -483,8 +517,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -508,15 +547,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -539,6 +583,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -571,9 +616,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -598,9 +645,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -620,8 +671,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -630,7 +684,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -651,12 +712,15 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -668,10 +732,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -696,13 +763,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -710,6 +783,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -732,10 +807,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -745,7 +825,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -756,7 +840,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net462/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net462/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net462/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net462/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net472/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net472/PublicAPI.Shipped.txt index 268d42ab..f09a77ad 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net472/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net472/PublicAPI.Shipped.txt @@ -142,10 +142,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -175,8 +180,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -192,6 +201,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -204,8 +216,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -251,9 +266,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -276,7 +293,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -292,7 +311,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -300,7 +321,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -318,12 +346,15 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -343,6 +374,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -362,6 +395,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -483,8 +517,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -508,15 +547,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -539,6 +583,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -571,9 +616,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -598,9 +645,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -620,8 +671,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -630,7 +684,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -651,12 +712,15 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -668,10 +732,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -696,13 +763,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -710,6 +783,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -732,10 +807,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -745,7 +825,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -756,7 +840,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net472/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net472/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net472/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net472/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net48/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net48/PublicAPI.Shipped.txt index 268d42ab..f09a77ad 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net48/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net48/PublicAPI.Shipped.txt @@ -142,10 +142,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -175,8 +180,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -192,6 +201,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -204,8 +216,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -251,9 +266,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -276,7 +293,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -292,7 +311,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -300,7 +321,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -318,12 +346,15 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -343,6 +374,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -362,6 +395,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -483,8 +517,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -508,15 +547,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -539,6 +583,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -571,9 +616,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -598,9 +645,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -620,8 +671,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -630,7 +684,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -651,12 +712,15 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -668,10 +732,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -696,13 +763,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -710,6 +783,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -732,10 +807,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -745,7 +825,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -756,7 +840,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net48/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net48/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net48/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net48/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net481/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net481/PublicAPI.Shipped.txt index 268d42ab..f09a77ad 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net481/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net481/PublicAPI.Shipped.txt @@ -142,10 +142,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -175,8 +180,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -192,6 +201,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -204,8 +216,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -251,9 +266,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -276,7 +293,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -292,7 +311,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -300,7 +321,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -318,12 +346,15 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -343,6 +374,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -362,6 +395,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -483,8 +517,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -508,15 +547,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -539,6 +583,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -571,9 +616,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -598,9 +645,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -620,8 +671,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -630,7 +684,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -651,12 +712,15 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -668,10 +732,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -696,13 +763,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -710,6 +783,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -732,10 +807,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -745,7 +825,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -756,7 +840,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net481/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net481/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net481/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net481/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net8.0/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net8.0/PublicAPI.Shipped.txt index 6b97d4f3..a179b513 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net8.0/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net8.0/PublicAPI.Shipped.txt @@ -142,10 +142,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -175,8 +180,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -192,6 +201,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -204,8 +216,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -251,9 +266,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -276,7 +293,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -292,7 +311,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -300,7 +321,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -318,12 +346,15 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -343,6 +374,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -362,6 +395,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -483,8 +517,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -508,15 +547,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -539,6 +583,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -571,9 +616,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -598,9 +645,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -620,8 +671,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -630,7 +684,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -651,12 +712,15 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -668,10 +732,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -696,13 +763,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -710,6 +783,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -734,10 +809,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -747,7 +827,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -758,7 +842,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net8.0/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net8.0/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net8.0/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/ReactiveUI.Primitives/PublicAPI/net9.0/PublicAPI.Shipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net9.0/PublicAPI.Shipped.txt index 18ae7b29..b5d9b271 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net9.0/PublicAPI.Shipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net9.0/PublicAPI.Shipped.txt @@ -142,10 +142,15 @@ ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primit ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoConnect(int subscriberCount) -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).AutoShare() -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(ReactiveUI.Primitives.ConnectableSignal!).RefCount() -> System.IObservable! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!) ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Multicast(ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish() -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Publish(System.Func!, System.IObservable!>! selector) -> System.IObservable! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Replay(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive() -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).ReplayLive(int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! ReactiveUI.Primitives.ConnectableSignalExtensions.extension(System.IObservable!).Share() -> ReactiveUI.Primitives.ConnectableSignal! @@ -175,8 +180,12 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Cas ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepType() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Blend(int maxConcurrent) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!>!).Merge(int maxConcurrent) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!) ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToObservable(System.Threading.CancellationToken cancellationToken) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Collections.Generic.IEnumerable!).ToSignal(System.Threading.CancellationToken cancellationToken) -> System.IObservable! @@ -192,6 +201,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!>!).Race() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Switch() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).SwitchTo() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!) +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Chain() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!>!).Concat() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Aggregate(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).All(System.Func! predicate) -> System.IObservable! @@ -204,8 +216,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AnyAsy ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Append(T value) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).AsObservable() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Bind(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan) -> System.IObservable!>! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Calm(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Catch(System.Func!>! handler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Chain(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArray() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).CollectArrayAsync() -> System.Threading.Tasks.Task! @@ -251,9 +266,11 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Distin ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Do(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).DoWith(TState state, System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Expire(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Finally(System.Action! finallyAction) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).FirstOrDefaultAsync(T defaultValue) -> System.Threading.Tasks.Task! @@ -276,7 +293,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Lead(T ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).LongCount(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Map(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapIndexed(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).MapWith(TState state, System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Merge(System.IObservable! second) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).ObserveOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Pair(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).PairLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -292,7 +311,9 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Rescue ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Resume(System.IObservable! fallback) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Scan(TAccumulate seed, System.Func! accumulator) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.Func!>! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectMany(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Shift(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Skip(int count) -> System.IObservable! @@ -300,7 +321,14 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SkipWh ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Spark() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Stabilize(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(System.Collections.Generic.IEnumerable! values) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).StartWith(params T[]! values) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeOn(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SubscribeSafe(System.IObserver! observer) -> System.IDisposable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.IObservable! source16, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.IObservable! source15, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! source2, System.IObservable! source3, System.IObservable! source4, System.IObservable! source5, System.IObservable! source6, System.IObservable! source7, System.IObservable! source8, System.IObservable! source9, System.IObservable! source10, System.IObservable! source11, System.IObservable! source12, System.IObservable! source13, System.IObservable! source14, System.Func! selector) -> System.IObservable! @@ -318,12 +346,16 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLa ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SyncLatest(System.IObservable! right, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(System.Threading.Lock! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Synchronize(object! gate) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SynchronizeObject(object! gate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Take(int count) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeUntil(System.IObservable! other) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TakeWhile(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Tap(System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TapWith(TState state, System.Action! onNext) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Throttle(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval() -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).TimeInterval(ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Timestamp() -> System.IObservable>! @@ -343,6 +375,8 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).KeepNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereNotNull() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!) +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToObservable() -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToSignal() -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.Threading.Tasks.Task!).ToTask() -> System.Threading.Tasks.Task! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!) ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Choose(System.Func! chooser) -> System.IObservable! @@ -362,6 +396,7 @@ ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable(System.IObservable!).Buffer(int count) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Buffer(int count, int skip) -> System.IObservable!>! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! +ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Select(System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).SelectWith(TState state, System.Func! selector) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).Where(System.Func! predicate) -> System.IObservable! ReactiveUI.Primitives.LinqExtensions.extension(System.IObservable!).WhereWith(TState state, System.Func! predicate) -> System.IObservable! @@ -483,8 +518,13 @@ static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this Rea static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoConnect(this ReactiveUI.Primitives.ConnectableSignal! source, int subscriberCount) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.AutoShare(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! static ReactiveUI.Primitives.ConnectableSignalExtensions.Multicast(this System.IObservable! source, ReactiveUI.Primitives.Signals.ISignal! hub) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source, System.Func!, System.IObservable!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Publish(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.RefCount(this ReactiveUI.Primitives.ConnectableSignal! source) -> System.IObservable! +static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Replay(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! +static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.ReplayLive(this System.IObservable! source, int bufferSize, System.TimeSpan window) -> ReactiveUI.Primitives.ConnectableSignal! static ReactiveUI.Primitives.ConnectableSignalExtensions.Share(this System.IObservable! source) -> ReactiveUI.Primitives.ConnectableSignal! @@ -508,15 +548,20 @@ static ReactiveUI.Primitives.LinqExtensions.Append(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.AsObservable(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Bind(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Blend(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Blend(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(System.IObservable![]! sources, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.BlendUnique(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! +static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, System.TimeSpan timeSpan, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Buffer(this System.IObservable! source, int count, int skip) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Calm(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CastTo(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Catch(this System.IObservable! source, System.Func!>! handler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Chain(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Choose(this System.IObservable! source, System.Func! chooser) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CollectArray(this System.IObservable! source) -> System.IObservable! @@ -539,6 +584,7 @@ static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! source, System.IObservable! source2, System.IObservable! source3, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.CombineLatest(this System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Concat(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Contains(this System.IObservable! source, T value, System.Collections.Generic.IEqualityComparer? comparer) -> System.IObservable! @@ -571,9 +617,11 @@ static ReactiveUI.Primitives.LinqExtensions.DistinctUntilChangedBy(this static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Do(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.DoWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Expire(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Finally(this System.IObservable! source, System.Action! finallyAction) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.FirstAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.FirstOrDefaultAsync(this System.IObservable! source, T defaultValue) -> System.Threading.Tasks.Task! @@ -598,9 +646,13 @@ static ReactiveUI.Primitives.LinqExtensions.Lead(this System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.LongCount(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Map(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.MapIndexed(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.MapWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Materialize(this System.IObservable! left) -> System.IObservable>! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Merge(this System.IObservable! source, System.IObservable! second) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ObserveOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Pair(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.PairLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! @@ -620,8 +672,11 @@ static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservabl static ReactiveUI.Primitives.LinqExtensions.Sample(this System.IObservable! left, System.TimeSpan interval, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Scan(this System.IObservable! source, TAccumulate seed, System.Func! accumulator) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Select(this System.IObservable! source, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! collectionSelector, System.Func! resultSelector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SelectMany(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SelectWith(this System.IObservable! source, TState state, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Shift(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! @@ -630,7 +685,14 @@ static ReactiveUI.Primitives.LinqExtensions.SkipWhile(this System.IObservable static ReactiveUI.Primitives.LinqExtensions.Spark(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Stabilize(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.StartWith(this System.IObservable! source, params T[]! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SubscribeOn(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IDisposable! +static ReactiveUI.Primitives.LinqExtensions.SubscribeSafe(this System.IObservable! source, System.IObserver! observer) -> System.IDisposable! static ReactiveUI.Primitives.LinqExtensions.Switch(this System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchSelect(this System.IObservable! source, System.Func!>! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.SwitchTo(this System.IObservable!>! sources) -> System.IObservable! @@ -651,12 +713,16 @@ static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this static ReactiveUI.Primitives.LinqExtensions.SyncLatest(this System.IObservable! source, System.IObservable! right, System.Func! selector) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, System.Threading.Lock! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Synchronize(this System.IObservable! source, object! gate) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.SynchronizeObject(this System.IObservable! source, object! gate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Take(this System.IObservable! source, int count) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeUntil(this System.IObservable! source, System.IObservable! other) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TakeWhile(this System.IObservable! source, System.Func! predicate) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.Tap(this System.IObservable! source, System.Action! onNext, System.Action! onError, System.Action! onCompleted) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TapWith(this System.IObservable! source, TState state, System.Action! onNext) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.Throttle(this System.IObservable! source, System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.TimeInterval(this System.IObservable! source, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> System.IObservable>! static ReactiveUI.Primitives.LinqExtensions.Timeout(this System.IObservable! left, System.TimeSpan dueTime) -> System.IObservable! @@ -668,10 +734,13 @@ static ReactiveUI.Primitives.LinqExtensions.ToArrayAsync(this System.IObserva static ReactiveUI.Primitives.LinqExtensions.ToList(this System.IObservable! source) -> System.IObservable!>! static ReactiveUI.Primitives.LinqExtensions.ToListAsync(this System.IObservable! source) -> System.Threading.Tasks.Task!>! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToObservable(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Collections.Generic.IEnumerable! values, System.Threading.CancellationToken cancellationToken) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.IObservable! source) -> System.IObservable! +static ReactiveUI.Primitives.LinqExtensions.ToSignal(this System.Threading.Tasks.Task! task) -> System.IObservable! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.IObservable! source, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task! static ReactiveUI.Primitives.LinqExtensions.ToTask(this System.Threading.Tasks.Task! task) -> System.Threading.Tasks.Task! @@ -696,13 +765,19 @@ static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, Syste static ReactiveUI.Primitives.Signals.Signal.After(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Blend(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Chain(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Concat(params System.IObservable![]! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Create(System.Func!, System.Threading.Tasks.Task!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateSafe(System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.CreateWithState(TState state, System.Func!, System.IDisposable!>! subscribe, bool isRequiredSubscribeOnCurrentThread) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Defer(System.Func!>!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Delayable(System.Func! isDelayed, System.Func!, System.Collections.Generic.IEnumerable!>! flushDistinct) -> ReactiveUI.Primitives.Signals.DelayableNotificationSignal! static ReactiveUI.Primitives.Signals.Signal.Emit(ReactiveUI.Primitives.RxVoid value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(bool value) -> System.IObservable! @@ -710,6 +785,8 @@ static ReactiveUI.Primitives.Signals.Signal.Emit(int value) -> System.IObservabl static ReactiveUI.Primitives.Signals.Signal.Emit(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Emit(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.EmitRxVoid() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty() -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Empty(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Every(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Fail(System.Exception! error) -> System.IObservable! @@ -734,10 +811,15 @@ static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Threading.Tasks.T static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler) -> ReactiveUI.Primitives.Signals.ITaskSignal! static ReactiveUI.Primitives.Signals.Signal.FromTask(System.Func!>! actionAsync, ReactiveUI.Primitives.Concurrency.ISequencer? scheduler, System.Threading.CancellationTokenSource? cancellationTokenSource) -> ReactiveUI.Primitives.Signals.ITaskSignal! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Interval(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Iterate(TState initialState, System.Func! condition, System.Func! iterator, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Lazy(System.Func!>! observableFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Loop(T value, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(System.Collections.Generic.IEnumerable!>! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Merge(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Never() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None() -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.None(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, T witness) -> System.IObservable! @@ -747,7 +829,11 @@ static ReactiveUI.Primitives.Signals.Signal.PairLatest(S static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Pulse(System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Race(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Range(int start, int count, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Recover(params System.IObservable![]! sources) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Return(T value, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Scheduled(ReactiveUI.Primitives.Concurrency.ISequencer! scheduler, System.IObserver? defaultObserver) -> ReactiveUI.Primitives.Signals.ScheduledSignal! static ReactiveUI.Primitives.Signals.Signal.Sequence(int start, int count) -> System.IObservable! @@ -758,7 +844,16 @@ static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action) -> Syst static ReactiveUI.Primitives.Signals.Signal.Start(System.Action! action, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Start(System.Func! function, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Switch(System.IObservable!>! sources) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.SyncLatest(System.IObservable! left, System.IObservable! right, System.Func! selector) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Throw(System.Exception! error, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.DateTimeOffset dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period) -> System.IObservable! +static ReactiveUI.Primitives.Signals.Signal.Timer(System.TimeSpan dueTime, System.TimeSpan period, ReactiveUI.Primitives.Concurrency.ISequencer! scheduler) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Unfold(TState initialState, System.Func! condition, System.Func! iterate, System.Func! resultSelector) -> System.IObservable! static ReactiveUI.Primitives.Signals.Signal.Use(System.Func! resourceFactory, System.Func!>! signalFactory) -> System.IObservable! static ReactiveUI.Primitives.Signals.SignalExtensions.Collect(this System.IObservable! source, System.TimeSpan timeSpan) -> System.IObservable!>! diff --git a/src/ReactiveUI.Primitives/PublicAPI/net9.0/PublicAPI.Unshipped.txt b/src/ReactiveUI.Primitives/PublicAPI/net9.0/PublicAPI.Unshipped.txt index 7dc5c581..c299f647 100644 --- a/src/ReactiveUI.Primitives/PublicAPI/net9.0/PublicAPI.Unshipped.txt +++ b/src/ReactiveUI.Primitives/PublicAPI/net9.0/PublicAPI.Unshipped.txt @@ -1 +1,59 @@ #nullable enable + +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.AsyncSubscriptionLifetime() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Complete() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Dispose() -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.IsCancellationRequested.get -> bool +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.SetSubscription(System.IDisposable? disposable) -> void +ReactiveUI.Primitives.Advanced.AsyncSubscriptionLifetime.Token.get -> System.Threading.CancellationToken +ReactiveUI.Primitives.Advanced.MapIndexedSignal +ReactiveUI.Primitives.Advanced.MapIndexedSignal.IsRequiredSubscribeOnCurrentThread() -> bool +ReactiveUI.Primitives.Advanced.MapIndexedSignal.MapIndexedSignal(System.IObservable! source, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.MapIndexedWitness +ReactiveUI.Primitives.Advanced.MapIndexedWitness.MapIndexedWitness(System.IObserver! observer, System.Func! selector) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.MapIndexedWitness.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.MaxConcurrentBlendCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator.Run(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> ReactiveUI.Primitives.Advanced.MaxConcurrentBlendCoordinator! +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.MaxConcurrentEnumerableBlendSignal(System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> void +ReactiveUI.Primitives.Advanced.MaxConcurrentEnumerableBlendSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.OnNext(TSource value) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SelectManyEnumerableObserver(System.IObserver! observer, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.SelectManyEnumerableSignal(System.IObservable! source, System.Func!>! selector) -> void +ReactiveUI.Primitives.Advanced.SelectManyEnumerableSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.Dispose() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SubscribeSafeObserver.SubscribeSafeObserver(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.SynchronizeObjectSignal.SynchronizeObjectSignal(System.IObservable! source, object! gate) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.Dispose() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnCompleted() -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnError(System.Exception! error) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.OnNext(T value) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SetSubscription(System.IDisposable! subscription) -> void +ReactiveUI.Primitives.Advanced.SynchronizeObjectWitness.SynchronizeObjectWitness(System.IObserver! observer, object! gate) -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Dispose() -> void +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.Run(System.IObservable!>! sources) -> ReactiveUI.Primitives.Advanced.TaskChainCoordinator! +ReactiveUI.Primitives.Advanced.TaskChainCoordinator.TaskChainCoordinator(System.IObserver! observer) -> void +ReactiveUI.Primitives.Advanced.TaskChainSignal +ReactiveUI.Primitives.Advanced.TaskChainSignal.Subscribe(System.IObserver! observer) -> System.IDisposable! +ReactiveUI.Primitives.Advanced.TaskChainSignal.TaskChainSignal(System.IObservable!>! sources) -> void diff --git a/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs b/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs index 73518485..758b2afc 100644 --- a/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs +++ b/src/tests/ReactiveUI.Primitives.Async.Tests/TimeBasedOperatorTests.cs @@ -667,11 +667,12 @@ public async Task WhenThrottleReceivesRapidValues_ThenOnlyEmitsLatest() { const int SecondValue = 2; const int LastValue = 3; + ManualTimeProvider manualProvider = new(); DirectSource source = new(); List items = []; TaskCompletionSource completed = new(TaskCreationOptions.RunContinuationsAsynchronously); TaskCompletionSource lastEmitted = new(TaskCreationOptions.RunContinuationsAsynchronously); - await using var sub = await source.Throttle(TimeSpan.FromMilliseconds(50)).SubscribeAsync( + await using var sub = await source.Throttle(TimeSpan.FromMilliseconds(50), manualProvider).SubscribeAsync( (x, ct) => { _ = ct; @@ -689,9 +690,8 @@ public async Task WhenThrottleReceivesRapidValues_ThenOnlyEmitsLatest() await source.EmitNext(SecondValue); await source.EmitNext(LastValue); - // Wait for the throttle window to actually fire the latest value rather than relying on a - // wall-clock delay — Task.Delay drifts on slow CI runners (macOS arm64 saw the throttle - // fail to fire inside the 200ms window). + await Assert.That(manualProvider.TimerCount).IsEqualTo(LastValue); + manualProvider.FireAll(); await lastEmitted.Task.WaitAsync(TimeSpan.FromSeconds(5)); await source.Complete(Result.Success); await completed.Task.WaitAsync(TimeSpan.FromSeconds(5)); @@ -770,6 +770,108 @@ public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSp throw new InvalidOperationException("timer creation failed"); } + /// A that records one-shot timers and exposes an explicit fire point for deterministic debounce supersession tests. + private sealed class ManualTimeProvider : TimeProvider + { + /// Protects timer collection access. + private readonly Lock _gate = new(); + + /// The timers created by this provider. + private readonly List _timers = []; + + /// Gets the number of timers created by this provider. + internal int TimerCount + { + get + { + lock (_gate) + { + return _timers.Count; + } + } + } + + /// Creates a manual timer and stores it until is invoked. + /// The callback to invoke when the timer is fired. + /// The state object passed to the callback. + /// The initial delay (recorded by caller behavior, not elapsed by this provider). + /// The interval (ignored; timers are one-shot in these tests). + /// A manual instance. + public override ITimer CreateTimer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period) + { + _ = dueTime; + _ = period; + ManualTimer timer = new(callback, state); + lock (_gate) + { + _timers.Add(timer); + } + + return timer; + } + + /// Fires every timer that has been created so far. + internal void FireAll() + { + ManualTimer[] timers; + lock (_gate) + { + timers = [.. _timers]; + } + + foreach (var timer in timers) + { + timer.Fire(); + } + } + + /// Manual one-shot timer used by . + /// The callback to invoke. + /// The state object passed to the callback. + private sealed class ManualTimer(TimerCallback callback, object? state) : ITimer + { + /// Non-zero once the timer has been disposed. + private int _disposed; + + /// Non-zero once the timer has fired. + private int _fired; + + /// No-op change; returns whether the timer is still active. + /// The due time (ignored). + /// The period (ignored). + /// when the timer is still active. + public bool Change(TimeSpan dueTime, TimeSpan period) + { + _ = dueTime; + _ = period; + return Volatile.Read(ref _disposed) == 0; + } + + /// Marks the timer as disposed. + public void Dispose() => Interlocked.Exchange(ref _disposed, 1); + + /// Marks the timer as disposed. + /// A completed . + public ValueTask DisposeAsync() + { + Dispose(); + return default; + } + + /// Invokes the callback once if the timer has not been disposed. + internal void Fire() + { + if (Volatile.Read(ref _disposed) != 0 || + Interlocked.Exchange(ref _fired, 1) != 0) + { + return; + } + + callback(state); + } + } + } + /// /// A that fires the timer callback synchronously during /// , completing the delay immediately. Used to deterministically diff --git a/src/tests/ReactiveUI.Primitives.Tests/AsyncSubscriptionLifetimeTests.cs b/src/tests/ReactiveUI.Primitives.Tests/AsyncSubscriptionLifetimeTests.cs new file mode 100644 index 00000000..78545f21 --- /dev/null +++ b/src/tests/ReactiveUI.Primitives.Tests/AsyncSubscriptionLifetimeTests.cs @@ -0,0 +1,62 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using ReactiveUI.Primitives.Advanced; + +namespace ReactiveUI.Primitives.Tests; + +/// Tests for . +public sealed class AsyncSubscriptionLifetimeTests +{ + /// Verifies disposal before completion cancels once and disposes the assigned subscription. + /// A task representing the asynchronous operation. + [Test] + public async Task DisposeBeforeCompletionCancelsAndDisposesSubscriptionOnce() + { + AsyncSubscriptionLifetime lifetime = new(); + var token = lifetime.Token; + RecordingDisposable subscription = new(); + lifetime.SetSubscription(subscription); + + lifetime.Dispose(); + lifetime.Dispose(); + + await Assert.That(token.IsCancellationRequested).IsTrue(); + await Assert.That(lifetime.IsCancellationRequested).IsTrue(); + await Assert.That(subscription.DisposeCount).IsEqualTo(1); + } + + /// Verifies a subscription assigned after disposal is disposed immediately. + /// A task representing the asynchronous operation. + [Test] + public async Task SetSubscriptionAfterDisposalDisposesAssignedSubscription() + { + AsyncSubscriptionLifetime lifetime = new(); + RecordingDisposable subscription = new(); + + lifetime.Dispose(); + lifetime.Complete(); + lifetime.SetSubscription(subscription); + + await Assert.That(subscription.DisposeCount).IsEqualTo(1); + } + + /// Verifies completion releases cancellation without requesting cancellation. + /// A task representing the asynchronous operation. + [Test] + public async Task CompleteBeforeDisposeDisposesSubscriptionWithoutCancellation() + { + AsyncSubscriptionLifetime lifetime = new(); + var token = lifetime.Token; + RecordingDisposable subscription = new(); + lifetime.SetSubscription(subscription); + + lifetime.Complete(); + lifetime.Dispose(); + + await Assert.That(token.IsCancellationRequested).IsFalse(); + await Assert.That(lifetime.IsCancellationRequested).IsFalse(); + await Assert.That(subscription.DisposeCount).IsEqualTo(1); + } +} diff --git a/src/tests/ReactiveUI.Primitives.Tests/ConnectableSignalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/ConnectableSignalTests.cs index 06e52a0e..e0b16dda 100644 --- a/src/tests/ReactiveUI.Primitives.Tests/ConnectableSignalTests.cs +++ b/src/tests/ReactiveUI.Primitives.Tests/ConnectableSignalTests.cs @@ -2,6 +2,7 @@ // ReactiveUI Association Incorporated licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. +using ReactiveUI.Primitives.Disposables; using ReactiveUI.Primitives.Signals; namespace ReactiveUI.Primitives.Tests; @@ -105,4 +106,133 @@ public async Task ConnectableAliasesValidateAndConnectAtThreshold() replayed.Subscribe(replayValues.Add); await Assert.That(replayValues.SequenceEqual(ExpectedReplayValues[..1])).IsTrue(); } + + /// Verifies direct connect handles reuse, terminate, and dispose idempotently. + /// A task representing the asynchronous operation. + [Test] + public async Task ConnectableSignalDirectConnectReusesConnectionAndForwardsTerminalError() + { + Assert.Throws(() => _ = new ConnectableSignal(null!, new Signal())); + Assert.Throws(() => _ = new ConnectableSignal(Signal.Silent(), null!)); + + Signal source = new(); + var sourceSubscriptions = 0; + var sourceDisposals = 0; + var cold = Signal.Create(observer => + { + sourceSubscriptions++; + var inner = source.Subscribe(observer); + return new ActionDisposable(() => + { + sourceDisposals++; + inner.Dispose(); + }); + }); + + ConnectableSignal connectable = new(cold, new Signal()); + RecordingWitness recorded = new(); + using var recordedSubscription = connectable.Subscribe(recorded); + + var firstConnection = connectable.Connect(); + var secondConnection = connectable.Connect(); + await Assert.That(secondConnection).IsSameReferenceAs(firstConnection); + await Assert.That(sourceSubscriptions).IsEqualTo(1); + + InvalidOperationException expected = new("connectable"); + source.OnError(expected); + await Assert.That(recorded.Errors.Count).IsEqualTo(1); + await Assert.That(recorded.Errors[0]).IsSameReferenceAs(expected); + + firstConnection.Dispose(); + firstConnection.Dispose(); + await Assert.That(sourceDisposals).IsEqualTo(1); + await Assert.That(connectable.Connect()).IsSameReferenceAs(Scope.Empty); + } + + /// Verifies Rx connectable aliases share, replay, and route selector failures. + /// A task representing the asynchronous operation. + [Test] + public async Task ConnectableRxAliasesShareReplayAndRouteSelectorFailures() + { + Signal source = new(); + var sourceSubscriptions = 0; + var sourceDisposals = 0; + var cold = Signal.Create(observer => + { + sourceSubscriptions++; + var inner = source.Subscribe(observer); + return new ActionDisposable(() => + { + sourceDisposals++; + inner.Dispose(); + }); + }); + + List refCountValues = []; + var refCountSubscription = cold.Publish().RefCount().Subscribe(refCountValues.Add); + source.OnNext(FirstSharedValue); + refCountSubscription.Dispose(); + source.OnNext(SecondSharedValue); + + await Assert.That(refCountValues.SequenceEqual(ExpectedFirstSharedValues)).IsTrue(); + await Assert.That(sourceSubscriptions).IsEqualTo(1); + await Assert.That(sourceDisposals).IsEqualTo(1); + + List selectedValues = []; + using var selectedSubscription = ConnectableSignalExtensions + .Publish(cold, shared => shared.Map(static value => value + SecondSharedValue)) + .Subscribe(selectedValues.Add); + source.OnNext(FirstSharedValue); + + await Assert.That(selectedValues.SequenceEqual([FirstSharedValue + SecondSharedValue])).IsTrue(); + + Exception? selectorError = null; + InvalidOperationException expectedSelectorError = new("selector"); + ConnectableSignalExtensions.Publish(cold, _ => throw expectedSelectorError) + .Subscribe(_ => { }, error => selectorError = error); + + Exception? nullSelectorError = null; + ConnectableSignalExtensions.Publish(cold, _ => null!) + .Subscribe(_ => { }, error => nullSelectorError = error); + + await Assert.That(selectorError).IsSameReferenceAs(expectedSelectorError); + await Assert.That(nullSelectorError is InvalidOperationException).IsTrue(); + + var replay = cold.Replay(); + using var replayConnection = replay.Connect(); + source.OnNext(FirstReplayValue); + List replayValues = []; + replay.Subscribe(replayValues.Add); + source.OnNext(SecondReplayValue); + + await Assert.That(replayValues.SequenceEqual(ExpectedReplayValues)).IsTrue(); + + Assert.Throws(() => ConnectableSignalExtensions.RefCount(null!)); + Assert.Throws(() => + ConnectableSignalExtensions.Publish(null!, static source => source)); + Assert.Throws(() => ConnectableSignalExtensions.Publish(cold, null!)); + } + + /// Verifies RefCount does not reconnect a published source after its hub has completed. + /// A task representing the asynchronous operation. + [Test] + public async Task RefCountDoesNotReconnectAfterPublishedSourceCompletes() + { + const int ExpectedCompletions = 2; + var sourceSubscriptions = 0; + var completions = 0; + var cold = Signal.Create(observer => + { + sourceSubscriptions++; + observer.OnCompleted(); + return Scope.Empty; + }); + var shared = cold.Publish().RefCount(); + + shared.Subscribe(static _ => { }, () => completions++).Dispose(); + shared.Subscribe(static _ => { }, () => completions++).Dispose(); + + await Assert.That(completions).IsEqualTo(ExpectedCompletions); + await Assert.That(sourceSubscriptions).IsEqualTo(1); + } } diff --git a/src/tests/ReactiveUI.Primitives.Tests/EventPatternTests.cs b/src/tests/ReactiveUI.Primitives.Tests/EventPatternTests.cs index 3fdfd7c6..78bd0f1d 100644 --- a/src/tests/ReactiveUI.Primitives.Tests/EventPatternTests.cs +++ b/src/tests/ReactiveUI.Primitives.Tests/EventPatternTests.cs @@ -2,6 +2,7 @@ // ReactiveUI Association Incorporated licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. +using System.Collections.Specialized; using System.ComponentModel; using System.Diagnostics.CodeAnalysis; using ReactiveUI.Primitives.Core; @@ -65,6 +66,39 @@ public async Task GenericFromEventPatternCoversPropertyChangedGenericAndUnsuppor Signal.FromEventPattern(_ => { }, _ => { }).Subscribe(_ => { })); } + /// Verifies generic event factories support collection and list event handlers used by binding sources. + /// A task representing the asynchronous operation. + [Test] + public async Task GenericFromEventPatternSupportsCollectionAndListHandlers() + { + CollectionChangedEventSource collectionSource = new(); + List collectionActions = []; + var collectionSubscription = + Signal.FromEventPattern( + handler => collectionSource.CollectionChanged += handler, + handler => collectionSource.CollectionChanged -= handler) + .Subscribe(pattern => collectionActions.Add(pattern.EventArgs.Action)); + + collectionSource.RaiseAdd(); + collectionSubscription.Dispose(); + collectionSource.RaiseAdd(); + + await Assert.That(collectionActions.SequenceEqual([NotifyCollectionChangedAction.Add])).IsTrue(); + + ListChangedEventSource listSource = new(); + List listChangeTypes = []; + var listSubscription = Signal.FromEventPattern( + handler => listSource.ListChanged += handler, + handler => listSource.ListChanged -= handler) + .Subscribe(pattern => listChangeTypes.Add(pattern.EventArgs.ListChangedType)); + + listSource.RaiseAdd(); + listSubscription.Dispose(); + listSource.RaiseAdd(); + + await Assert.That(listChangeTypes.SequenceEqual([ListChangedType.ItemAdded])).IsTrue(); + } + /// Verifies event-pattern bridges preserve sender/arguments and detach handlers on disposal. /// A task representing the asynchronous operation. [Test] @@ -134,6 +168,47 @@ private sealed class PropertyChangedEventSource public void Raise(string propertyName) => PropertyChanged?.Invoke(this, new(propertyName)); } + /// Source used to exercise event conversion. + private sealed class CollectionChangedEventSource + { + /// Raised by the test source. + [SuppressMessage( + "Roslynator", + "RCS1159:Use EventHandler", + Justification = + "This test deliberately covers the NotifyCollectionChangedEventHandler branch of the factory overload.")] + [SuppressMessage( + "Major Code Smell", + "S3908:Refactor this delegate to use 'System.EventHandler'.", + Justification = + "This test deliberately covers the NotifyCollectionChangedEventHandler branch of the factory overload.")] + public event NotifyCollectionChangedEventHandler? CollectionChanged; + + /// Raises with an add action. + public void RaiseAdd() => + CollectionChanged?.Invoke(this, new(NotifyCollectionChangedAction.Add, "value")); + } + + /// Source used to exercise event conversion. + private sealed class ListChangedEventSource + { + /// Raised by the test source. + [SuppressMessage( + "Roslynator", + "RCS1159:Use EventHandler", + Justification = + "This test deliberately covers the ListChangedEventHandler branch of the factory overload.")] + [SuppressMessage( + "Major Code Smell", + "S3908:Refactor this delegate to use 'System.EventHandler'.", + Justification = + "This test deliberately covers the ListChangedEventHandler branch of the factory overload.")] + public event ListChangedEventHandler? ListChanged; + + /// Raises with an item-added action. + public void RaiseAdd() => ListChanged?.Invoke(this, new(ListChangedType.ItemAdded, 0)); + } + /// Event arguments for fake click events. private sealed class FakeClickEventArgs : EventArgs { diff --git a/src/tests/ReactiveUI.Primitives.Tests/FatalExceptionHelperTests.cs b/src/tests/ReactiveUI.Primitives.Tests/FatalExceptionHelperTests.cs new file mode 100644 index 00000000..79263dcf --- /dev/null +++ b/src/tests/ReactiveUI.Primitives.Tests/FatalExceptionHelperTests.cs @@ -0,0 +1,51 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Diagnostics.CodeAnalysis; + +namespace ReactiveUI.Primitives.Tests; + +/// Tests for . +public sealed class FatalExceptionHelperTests +{ + /// Verifies fatal runtime exceptions are classified as fatal. + /// A task representing the asynchronous operation. + [Test] + public async Task IsFatalReturnsTrueForRuntimeFatalExceptions() + { + Exception[] fatal = + [ + CreateException(typeof(StackOverflowException)), + CreateException(typeof(AccessViolationException)), + new AppDomainUnloadedException(), + new BadImageFormatException(), + new CannotUnloadAppDomainException(), + new InvalidProgramException(), + CreateException(typeof(System.Threading.ThreadAbortException)), + CreateException(typeof(OutOfMemoryException)), + ]; + + foreach (var exception in fatal) + { + await Assert.That(FatalExceptionHelper.IsFatal(exception)).IsTrue(); + } + } + + /// Verifies non-fatal exceptions are not classified as fatal. + /// A task representing the asynchronous operation. + [Test] + public async Task IsFatalReturnsFalseForRecoverableExceptions() + { + await Assert.That(FatalExceptionHelper.IsFatal(new InsufficientMemoryException())).IsFalse(); + await Assert.That(FatalExceptionHelper.IsFatal(new InvalidOperationException())).IsFalse(); + } + + /// Creates an exception instance without invoking a platform-specific or runtime-reserved constructor. + /// The exception type. + /// An exception instance. + private static Exception CreateException( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] + Type exceptionType) => + (Exception)System.Runtime.CompilerServices.RuntimeHelpers.GetUninitializedObject(exceptionType); +} diff --git a/src/tests/ReactiveUI.Primitives.Tests/OptionalTests.cs b/src/tests/ReactiveUI.Primitives.Tests/OptionalTests.cs index 52c634fa..c71aee04 100644 --- a/src/tests/ReactiveUI.Primitives.Tests/OptionalTests.cs +++ b/src/tests/ReactiveUI.Primitives.Tests/OptionalTests.cs @@ -26,6 +26,8 @@ public async Task OptionalCoversEmptyAndValueContracts() Optional constructed = new(First); await Assert.That(constructed.HasValue).IsTrue(); await Assert.That(constructed.Value).IsEqualTo(First); + Optional nullOptional = new(null); + await Assert.That(nullOptional.HasValue).IsFalse(); var some = Optional.Some(Second); await Assert.That(some.HasValue).IsTrue(); await Assert.That(some.Value).IsEqualTo(Second); @@ -40,6 +42,8 @@ public async Task OptionalSupportsConversionHelpers() var converted = Optional.ToOptional(Second); Optional implicitOptional = First; var explicitValue = (int?)converted; + var none = Optional.None; + var some = Optional.Some(Second); await Assert.That(created.HasValue).IsTrue(); await Assert.That(created.Value).IsEqualTo(First); @@ -47,6 +51,8 @@ public async Task OptionalSupportsConversionHelpers() await Assert.That(converted.HasValue).IsTrue(); await Assert.That(explicitValue).IsEqualTo(Second); await Assert.That(implicitOptional.Value).IsEqualTo(First); + await Assert.That(none.HasValue).IsFalse(); + await Assert.That(some.Value).IsEqualTo(Second); } /// Covers optional string formatting for values and empty values. @@ -56,6 +62,7 @@ public async Task OptionalToStringFormatsValueAndNone() { await Assert.That(Optional.Some(First).ToString()).IsEqualTo("1"); await Assert.That(Optional.None.ToString()).IsEqualTo(""); + await Assert.That(Optional.Some(null).HasValue).IsFalse(); await Assert.That(Optional.Some(null).ToString()).IsEqualTo(""); } } diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.DynamicDataCompatibility.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.DynamicDataCompatibility.cs new file mode 100644 index 00000000..537cc87c --- /dev/null +++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.DynamicDataCompatibility.cs @@ -0,0 +1,445 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using ReactiveUI.Primitives.Concurrency; +using ReactiveUI.Primitives.Signals; + +namespace ReactiveUI.Primitives.Tests; + +/// Tests for Rx compatibility operators required by DynamicData migration. +public partial class RxNamesTests +{ + /// Verifies SubscribeSafe converts downstream value-handler exceptions into a terminal error. + /// A task representing the asynchronous operation. + [Test] + public async Task SubscribeSafeStopsAfterDownstreamOnNextException() + { + Signal source = new(); + InvalidOperationException expected = new(Boom); + Exception? observed = null; + var completed = 0; + var delivered = 0; + + using var subscription = source.SubscribeSafe( + _ => + { + delivered++; + throw expected; + }, + error => observed = error, + () => completed++); + + source.OnNext(One); + source.OnNext(Two); + + await Assert.That(delivered).IsEqualTo(One); + await Assert.That(observed).IsSameReferenceAs(expected); + await Assert.That(completed).IsEqualTo(0); + } + + /// Verifies enumerable Merge(maxConcurrent) waits to subscribe to later sources. + /// A task representing the asynchronous operation. + [Test] + public async Task EnumerableMergeHonorsMaxConcurrent() + { + Signal first = new(); + Signal second = new(); + List values = []; + + using var subscription = new IObservable[] { first, second }.Merge(One).Subscribe(values.Add); + + second.OnNext(Two); + first.OnNext(One); + + await Assert.That(values.SequenceEqual([One])).IsTrue(); + + first.OnCompleted(); + second.OnNext(Two); + + await Assert.That(values.SequenceEqual([One, Two])).IsTrue(); + } + + /// Verifies SelectMany subscribes to later inner sources before earlier inner sources complete. + /// A task representing the asynchronous operation. + [Test] + public async Task SelectManyMergesInnerSourcesConcurrently() + { + Signal outer = new(); + Signal first = new(); + Signal second = new(); + List values = []; + + using var subscription = outer.SelectMany(value => value == One ? first : second).Subscribe(values.Add); + + outer.OnNext(One); + outer.OnNext(Two); + second.OnNext(Two); + first.OnNext(One); + + await Assert.That(values.SequenceEqual([Two, One])).IsTrue(); + + first.OnCompleted(); + second.OnCompleted(); + outer.OnCompleted(); + } + + /// Verifies the Rx migration aliases used by DynamicData produce expected values. + /// A task representing the asynchronous operation. + [Test] + public async Task DynamicDataCompatibilityAliasesProduceExpectedValues() + { + var startWith = Collect(Signal.FromEnumerable([Three]).StartWith(One, Two)); + var enumerableSelectMany = Collect(Signal.FromEnumerable([One, Two]).SelectMany(static value => new[] { value, value + Ten })); + var repeatedSelectMany = Collect(Signal.FromEnumerable([One, Two]).SelectMany(Signal.Return(Ten))); + var recovered = Collect(Signal.Throw(new InvalidOperationException(Boom)).Catch((InvalidOperationException _) => Signal.Return(Two))); + + await Assert.That(startWith.SequenceEqual([One, Two, Three])).IsTrue(); + await Assert.That(enumerableSelectMany.SequenceEqual([One, One + Ten, Two, Two + Ten])).IsTrue(); + await Assert.That(repeatedSelectMany.SequenceEqual([Ten, Ten])).IsTrue(); + await Assert.That(recovered.SequenceEqual([Two])).IsTrue(); + } + + /// Verifies timed Buffer flushes scheduled batches and the final batch on completion. + /// A task representing the asynchronous operation. + [Test] + public async Task BufferFlushesTimedAndFinalBatches() + { + VirtualClock clock = new(DateTimeOffset.UnixEpoch); + Signal source = new(); + List> batches = []; + + using var subscription = source.Buffer(TimeSpan.FromTicks(Two), clock).Subscribe(batches.Add); + source.OnNext(One); + source.OnNext(Two); + + await Assert.That(batches.Count).IsEqualTo(0); + + clock.AdvanceBy(TimeSpan.FromTicks(Two)); + + await Assert.That(batches.Count).IsEqualTo(One); + await Assert.That(batches[0].SequenceEqual([One, Two])).IsTrue(); + + source.OnNext(Three); + source.OnCompleted(); + + await Assert.That(batches.Count).IsEqualTo(Two); + await Assert.That(batches[1].SequenceEqual([Three])).IsTrue(); + } + + /// Verifies Throttle emits only the latest value after the quiet period. + /// A task representing the asynchronous operation. + [Test] + public async Task ThrottleEmitsLatestAfterQuietPeriod() + { + VirtualClock clock = new(DateTimeOffset.UnixEpoch); + Signal source = new(); + List values = []; + + using var subscription = source.Throttle(TimeSpan.FromTicks(Two), clock).Subscribe(values.Add); + source.OnNext(One); + clock.AdvanceBy(TimeSpan.FromTicks(One)); + source.OnNext(Two); + clock.AdvanceBy(TimeSpan.FromTicks(One)); + + await Assert.That(values.Count).IsEqualTo(0); + + clock.AdvanceBy(TimeSpan.FromTicks(One)); + + await Assert.That(values.SequenceEqual([Two])).IsTrue(); + } + + /// Verifies Finally runs once when a subscription completes. + /// A task representing the asynchronous operation. + [Test] + public async Task FinallyRunsOnceOnCompletion() + { + var cleanupCount = 0; + List values = []; + + Signal.FromEnumerable([One]).Finally(() => cleanupCount++).Subscribe(values.Add); + + await Assert.That(values.SequenceEqual([One])).IsTrue(); + await Assert.That(cleanupCount).IsEqualTo(One); + } + + /// Verifies bounded enumerable merge handles completion, null sources, and source failures. + /// A task representing the asynchronous operation. + [Test] + public async Task EnumerableMergeMaxConcurrentHandlesTerminalAndFailureBranches() + { + var completed = 0; + Enumerable.Empty>().Merge(Two) + .Subscribe(_ => { }, ex => throw ex, () => completed++); + + await Assert.That(completed).IsEqualTo(One); + + Exception? nullError = null; + IEnumerable> sourcesWithNull = [null!]; + sourcesWithNull.Merge(One).Subscribe(_ => { }, error => nullError = error); + + await Assert.That(nullError is InvalidOperationException).IsTrue(); + + InvalidOperationException enumerableError = new("enumerable"); + Exception? observedEnumerableError = null; + ThrowingSources(enumerableError).Merge(One).Subscribe(_ => { }, error => observedEnumerableError = error); + + await Assert.That(observedEnumerableError).IsSameReferenceAs(enumerableError); + + InvalidOperationException sourceError = new("source"); + RecordingWitness failed = new(); + IEnumerable> scripted = + [ + new ScriptedObservable(observer => + { + observer.OnError(sourceError); + observer.OnCompleted(); + }) + ]; + scripted.Merge(One).Subscribe(failed); + + await Assert.That(failed.Errors.Count).IsEqualTo(One); + await Assert.That(failed.Errors[0]).IsSameReferenceAs(sourceError); + + Signal first = new(); + Signal second = new(); + var sequentialCompleted = 0; + using (new IObservable[] { first, second }.Merge(One) + .Subscribe(_ => { }, ex => throw ex, () => sequentialCompleted++)) + { + first.OnCompleted(); + second.OnCompleted(); + } + + await Assert.That(sequentialCompleted).IsEqualTo(One); + + Assert.Throws(() => ((IEnumerable>)null!).Merge()); + Assert.Throws(() => ((IEnumerable>)null!).Merge(One)); + Assert.Throws(() => scripted.Merge(0)); + } + + /// Verifies SubscribeSafe overloads stop after terminal notifications and dispose upstream. + /// A task representing the asynchronous operation. + [Test] + public async Task SubscribeSafeOverloadsStopAfterTerminalNotifications() + { + List values = []; + Signal.FromEnumerable([One]).SubscribeSafe(values.Add, _ => { }); + + await Assert.That(values.SequenceEqual([One])).IsTrue(); + + InvalidOperationException expected = new(Boom); + var errorOnlyCount = 0; + new ScriptedObservable(observer => + { + observer.OnError(expected); + observer.OnError(new InvalidOperationException("late")); + }).SubscribeSafe(error => errorOnlyCount += ReferenceEquals(error, expected) ? One : 0); + + await Assert.That(errorOnlyCount).IsEqualTo(One); + + var completed = 0; + new ScriptedObservable(observer => + { + observer.OnCompleted(); + observer.OnNext(Two); + observer.OnCompleted(); + }).SubscribeSafe(_ => { }, () => completed++); + + await Assert.That(completed).IsEqualTo(One); + + RecordingWitness witness = new(); + new ScriptedObservable(observer => + { + observer.OnCompleted(); + observer.OnNext(Three); + observer.OnError(new InvalidOperationException("late")); + }).SubscribeSafe(witness); + + await Assert.That(witness.Values.Count).IsEqualTo(0); + await Assert.That(witness.Completed).IsEqualTo(One); + await Assert.That(witness.Errors.Count).IsEqualTo(0); + } + + /// Verifies Rx side-effect, synchronization, indexed select, and task concat aliases. + /// A task representing the asynchronous operation. + [Test] + public async Task DynamicDataRxConvenienceAliasesCoverPublicEntryPoints() + { + List values = []; + List sideEffects = []; + var completed = 0; + Signal.FromEnumerable([One, Two]) + .Do( + value => sideEffects.Add("next:" + value), + error => sideEffects.Add("error:" + error.Message), + () => completed++) + .Subscribe(values.Add); + + await Assert.That(values.SequenceEqual([One, Two])).IsTrue(); + await Assert.That(sideEffects.SequenceEqual(["next:1", "next:2"])).IsTrue(); + await Assert.That(completed).IsEqualTo(One); + + Signal source = new(); + RecordingWitness synchronized = new(); + using (source.SynchronizeObject(new object()).Subscribe(synchronized)) + { + source.OnNext(One); + source.OnCompleted(); + } + + await Assert.That(synchronized.Values.SequenceEqual([One])).IsTrue(); + await Assert.That(synchronized.Completed).IsEqualTo(One); + + Signal errorSource = new(); + RecordingWitness synchronizedError = new(); + using (errorSource.SynchronizeObject(new object()).Subscribe(synchronizedError)) + { + errorSource.OnError(new InvalidOperationException(Boom)); + } + + await Assert.That(synchronizedError.Errors.Count).IsEqualTo(One); + await Assert.That(synchronizedError.Errors[0].Message).IsEqualTo(Boom); + + List aliasValues = []; + Signal.FromEnumerable([Three]).StartWith((IEnumerable)[One, Two]).Subscribe(aliasValues.Add); + Signal.FromEnumerable([One, Two]).Merge(Signal.FromEnumerable([Three])).Subscribe(aliasValues.Add); + Signal.FromEnumerable([One, Two]).Select(static (value, index) => value + index).Subscribe(aliasValues.Add); + Signal.FromEnumerable([Task.FromResult(One), Task.FromResult(Two)]).Concat().Subscribe(aliasValues.Add); + ((IEnumerable>)[Signal.Return(One), Signal.Return(Two)]).Merge().Subscribe(aliasValues.Add); + await Task.Yield(); + + await Assert.That(aliasValues.SequenceEqual([One, Two, Three, One, Two, Three, One, Three, One, Two, One, Two])) + .IsTrue(); + + await Assert.That(Signal.Return(One).Buffer(TimeSpan.FromTicks(One))).IsNotNull(); + await Assert.That(Signal.Return(One).Throttle(TimeSpan.FromTicks(One))).IsNotNull(); + + Assert.Throws(() => Signal.Return(One).Do(_ => { }, null!, () => { })); + Assert.Throws(() => Signal.Return(One).SynchronizeObject(null!)); + Assert.Throws(() => Signal.Return(One).Merge(null!)); + Assert.Throws(() => Signal.Return(One).Select((Func)null!)); + Assert.Throws(() => ((IObservable>)null!).Concat()); + } + + /// Verifies enumerable SelectMany forwards projected values and stops after failures or completion. + /// A task representing the asynchronous operation. + [Test] + public async Task SelectManyEnumerableStopsAfterErrorsAndTerminalNotifications() + { + RecordingWitness completed = new(); + new ScriptedObservable(observer => + { + observer.OnNext(One); + observer.OnCompleted(); + observer.OnCompleted(); + observer.OnNext(Two); + observer.OnError(new InvalidOperationException("late")); + }).SelectMany(static value => new[] { value }).Subscribe(completed); + + await Assert.That(completed.Values.SequenceEqual([One])).IsTrue(); + await Assert.That(completed.Completed).IsEqualTo(One); + await Assert.That(completed.Errors.Count).IsEqualTo(0); + + Signal nullSource = new(); + RecordingWitness nullResult = new(); + using var nullSubscription = nullSource + .SelectMany((Func>)(_ => null!)) + .Subscribe(nullResult); + nullSource.OnNext(One); + nullSource.OnNext(Two); + + await Assert.That(nullResult.Errors.Count).IsEqualTo(One); + await Assert.That(nullResult.Errors[0] is InvalidOperationException).IsTrue(); + + Signal throwingSource = new(); + RecordingWitness throwingResult = new(); + using var throwingSubscription = throwingSource + .SelectMany((Func>)(_ => throw new InvalidOperationException("selector"))) + .Subscribe(throwingResult); + throwingSource.OnNext(One); + + await Assert.That(throwingResult.Errors.Count).IsEqualTo(One); + await Assert.That(throwingResult.Errors[0].Message).IsEqualTo("selector"); + + Signal observerThrowingSource = new(); + RecordingWitness observerThrowingResult = new(); + using var observerThrowingSubscription = observerThrowingSource + .SelectMany(static value => new[] { value, value + One }) + .Subscribe( + value => + { + if (value != Two) + { + return; + } + + throw new InvalidOperationException("observer"); + }, + observerThrowingResult.OnError, + observerThrowingResult.OnCompleted); + observerThrowingSource.OnNext(One); + + await Assert.That(observerThrowingResult.Errors.Count).IsEqualTo(One); + await Assert.That(observerThrowingResult.Errors[0].Message).IsEqualTo("observer"); + + Signal disposedDuringEnumeration = new(); + var stoppedValues = 0; + IDisposable? stoppedSubscription = null; + stoppedSubscription = disposedDuringEnumeration + .SelectMany(static value => new[] { value, value + One }) + .Subscribe(value => + { + stoppedValues++; + stoppedSubscription?.Dispose(); + }); + disposedDuringEnumeration.OnNext(One); + + await Assert.That(stoppedValues).IsEqualTo(One); + + Assert.Throws(() => Signal.Return(One).SelectMany((Func>)null!)); + Assert.Throws(() => Signal.Return(One).SelectMany((IObservable)null!)); + } + + /// Produces an enumerable that throws when enumeration starts. + /// The exception thrown by the enumerable. + /// An enumerable observable sequence. + private static MoveNextThrowsEnumerable ThrowingSources(Exception error) + { + ArgumentNullException.ThrowIfNull(error); + + return new MoveNextThrowsEnumerable(error); + } + + /// An enumerable whose enumerator throws from . + /// The exception thrown by the enumerable. + private sealed class MoveNextThrowsEnumerable(Exception error) : + IEnumerable>, + IEnumerator> + { + /// + public IObservable Current => throw new InvalidOperationException("No current value is available."); + + /// + object System.Collections.IEnumerator.Current => Current; + + /// + public IEnumerator> GetEnumerator() => this; + + /// + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator(); + + /// + public bool MoveNext() => throw error; + + /// + public void Reset() + { + } + + /// + public void Dispose() + { + } + } +} diff --git a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs index e3948404..4493c469 100644 --- a/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs +++ b/src/tests/ReactiveUI.Primitives.Tests/RxNamesTests.cs @@ -16,7 +16,7 @@ namespace ReactiveUI.Primitives.Tests; /// Primitives-named counterpart. Each operator pair is one data-source row consumed by a single test body, so the /// behavior is asserted once and checked for both names (and for identity between them). /// -public class RxNamesTests +public partial class RxNamesTests { /// The multiplier/state used by projection cases. private const int Ten = 10; @@ -493,7 +493,7 @@ public void RxNamesThrowOnNullSource() public void RxNamesThrowOnNullSelector() { var source = Signal.FromEnumerable(_oneToFive); - Assert.Throws(() => source.Select(null!)); + Assert.Throws(() => source.Select((Func)null!)); Assert.Throws(() => source.SelectWith(Ten, null!)); Assert.Throws(() => source.Where(null!)); Assert.Throws(() => source.WhereWith(Two, null!)); @@ -502,7 +502,7 @@ public void RxNamesThrowOnNullSelector() Assert.Throws(() => source.Scan(Seed, null!)); Assert.Throws(() => source.Aggregate(Seed, null!)); Assert.Throws(() => source.DistinctUntilChangedBy(null!)); - Assert.Throws(() => source.SelectMany(null!)); + Assert.Throws(() => source.SelectMany((Func>)null!)); Assert.Throws(() => source.Zip(source, null!)); Assert.Throws(() => source.CombineLatest(source, null!)); Assert.Throws(() => source.WithLatestFrom(source, null!)); diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalCreateTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalCreateTests.cs index 5a8da689..cd6e6ddd 100644 --- a/src/tests/ReactiveUI.Primitives.Tests/SignalCreateTests.cs +++ b/src/tests/ReactiveUI.Primitives.Tests/SignalCreateTests.cs @@ -2,6 +2,8 @@ // ReactiveUI Association Incorporated licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. +using ReactiveUI.Primitives.Advanced; +using ReactiveUI.Primitives.Concurrency; using ReactiveUI.Primitives.Disposables; using ReactiveUI.Primitives.Signals; @@ -16,6 +18,9 @@ public class SignalCreateTests /// The first expected value. private const int First = 1; + /// The second expected value. + private const int Second = 2; + /// The third expected value. private const int Third = 3; @@ -30,7 +35,7 @@ public class SignalCreateTests public void Create_ArgumentChecking() { Assert.Throws(() => Signal.Create(default(Func, IDisposable>)!)); - Assert.Throws(() => Signal.Create(null!).Subscribe(null!)); + Assert.Throws(() => Signal.Create((Func, IDisposable>)null!).Subscribe(null!)); } /// Creates the null coalescing action. @@ -188,6 +193,182 @@ public async Task CreateWithStateFactoriesInvokeStatefulSubscribeCallbacks() Assert.Throws(() => Signal.Lazy(null!)); } + /// Verifies create overloads preserve current-thread subscription requirements. + /// A task representing the asynchronous operation. + [Test] + public async Task CreateWithCurrentThreadRequirementReportsAndEmitsSynchronously() + { + var created = Signal.Create( + observer => + { + observer.OnNext(CreatedValue); + observer.OnCompleted(); + return EmptyDisposable.Instance; + }, + true); + + RecordingWitness observer = new(); + created.Subscribe(observer); + + await Assert.That(((IRequireCurrentThread)created).IsRequiredSubscribeOnCurrentThread()).IsTrue(); + await Assert.That(observer.Values.SequenceEqual([CreatedValue])).IsTrue(); + await Assert.That(observer.Completed).IsEqualTo(1); + } + + /// Verifies asynchronous create overloads assign lifetimes, forward failures, and honor cancellation. + /// A task representing the asynchronous operation. + [Test] + public async Task AsyncCreateFactoriesAssignDisposablesAndForwardFailures() + { + var disposed = 0; + List values = []; + var created = Signal.Create(observer => + { + observer.OnNext(CreatedValue); + return Task.FromResult(new ActionDisposable(() => disposed++)); + }); + + var subscription = created.Subscribe(values.Add); + await Task.Yield(); + subscription.Dispose(); + + await Assert.That(values.SequenceEqual([CreatedValue])).IsTrue(); + await Assert.That(disposed).IsEqualTo(1); + + Exception? observed = null; + InvalidOperationException expected = new("async-create"); + Signal.Create((_, _) => Task.FromException(expected)) + .Subscribe(_ => { }, error => observed = error); + await Task.Yield(); + + await Assert.That(observed).IsSameReferenceAs(expected); + + TaskCompletionSource canceled = new(); + var cancellable = Signal.Create(async (_, cancellationToken) => + { + try + { + await Task.Delay(TimeSpan.FromSeconds(30), cancellationToken).ConfigureAwait(false); + } + catch (OperationCanceledException) + { + canceled.SetResult(); + throw; + } + + return EmptyDisposable.Instance; + }); + + var cancellableSubscription = cancellable.Subscribe(_ => { }); + cancellableSubscription.Dispose(); + await canceled.Task.WaitAsync(TimeSpan.FromSeconds(5)).ConfigureAwait(false); + + var nullDisposable = Signal.Create((_, _) => Task.FromResult(null!)); + var nullSubscription = nullDisposable.Subscribe(_ => { }); + await Task.Yield(); + nullSubscription.Dispose(); + + Assert.Throws(() => Signal.Create((Func, Task>)null!)); + Assert.Throws(() => + Signal.Create((Func, CancellationToken, Task>)null!)); + } + + /// Verifies asynchronous defer overloads emit, fail, and skip subscription after cancellation. + /// A task representing the asynchronous operation. + [Test] + public async Task AsyncDeferFactoriesEmitFailAndHonorCancellation() + { + List values = []; + Signal.Defer(() => Task.FromResult>(Signal.Emit(CreatedValue))).Subscribe(values.Add); + Signal.Defer(_ => Task.FromResult>(Signal.Emit(First))).Subscribe(values.Add); + await Task.Yield(); + + await Assert.That(values.SequenceEqual([CreatedValue, First])).IsTrue(); + + Exception? observed = null; + InvalidOperationException expected = new("defer"); + Signal.Defer(() => Task.FromException>(expected)) + .Subscribe(_ => { }, error => observed = error); + await Task.Yield(); + + await Assert.That(observed).IsSameReferenceAs(expected); + + TaskCompletionSource> delayedFactory = new(); + List canceledValues = []; + var deferred = Signal.Defer(_ => delayedFactory.Task); + var subscription = deferred.Subscribe(canceledValues.Add); + subscription.Dispose(); + delayedFactory.SetResult(Signal.Emit(Fourth)); + await Task.Yield(); + + await Assert.That(canceledValues.Count).IsEqualTo(0); + + Assert.Throws(() => Signal.Defer((Func>>)null!)); + Assert.Throws(() => + Signal.Defer((Func>>)null!)); + } + + /// Verifies Rx-named signal factories route to the corresponding Primitives factories. + /// A task representing the asynchronous operation. + [Test] + public async Task RxSignalFactoryAliasesRouteToPrimitiveFactories() + { + List values = []; + Signal.Return(CreatedValue, Sequencer.Immediate).Subscribe(values.Add); + Signal.Merge(Signal.Return(First), Signal.Return(Third)).Subscribe(values.Add); + Signal.Merge((IEnumerable>)[Signal.Return(Fourth)]).Subscribe(values.Add); + Signal.Switch(Signal.Return(Signal.Return(First))).Subscribe(values.Add); + Signal.Range(Second, Second).Subscribe(values.Add); + Signal.Range(Second, Second, Sequencer.Immediate).Subscribe(values.Add); + Signal.Concat(Signal.Return(Fourth), Signal.Return(First)).Subscribe(values.Add); + Signal.Concat((IEnumerable>)[Signal.Return(Second)]).Subscribe(values.Add); + + await Assert.That(values.SequenceEqual([ + CreatedValue, + First, + Third, + Fourth, + First, + Second, + Third, + Second, + Third, + Fourth, + First, + Second])).IsTrue(); + + var completions = 0; + Signal.Empty().Subscribe(_ => { }, ex => throw ex, () => completions++); + Signal.Empty(Sequencer.Immediate).Subscribe(_ => { }, ex => throw ex, () => completions++); + + await Assert.That(completions).IsEqualTo(Second); + + List errors = []; + InvalidOperationException expected = new("throw"); + Signal.Throw(expected, Sequencer.Immediate).Subscribe(_ => { }, errors.Add); + + await Assert.That(errors.Count).IsEqualTo(1); + await Assert.That(errors[0]).IsSameReferenceAs(expected); + + await Assert.That(Signal.Never()).IsNotNull(); + await Assert.That(Signal.Timer(TimeSpan.FromTicks(1))).IsNotNull(); + await Assert.That(Signal.Timer(TimeSpan.FromTicks(1), Sequencer.Immediate)).IsNotNull(); + await Assert.That(Signal.Timer(DateTimeOffset.UnixEpoch.AddTicks(1))).IsNotNull(); + await Assert.That(Signal.Timer(DateTimeOffset.UnixEpoch.AddTicks(1), Sequencer.Immediate)).IsNotNull(); + await Assert.That(Signal.Timer(TimeSpan.FromTicks(1), TimeSpan.FromTicks(1))).IsNotNull(); + await Assert.That(Signal.Timer(TimeSpan.FromTicks(1), TimeSpan.FromTicks(1), Sequencer.Immediate)) + .IsNotNull(); + await Assert.That(Signal.Interval(TimeSpan.FromTicks(1))).IsNotNull(); + + VirtualClock clock = new(DateTimeOffset.UnixEpoch); + List intervalValues = []; + using var interval = Signal.Interval(TimeSpan.FromTicks(1), clock).Take(Third).Subscribe(intervalValues.Add); + clock.AdvanceBy(TimeSpan.FromTicks(Third)); + + long[] expectedIntervalValues = [0L, First, Second]; + await Assert.That(intervalValues.SequenceEqual(expectedIntervalValues)).IsTrue(); + } + /// Records observer notifications. /// The observed value type. private sealed class Recorder : IObserver diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalDeferTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalDeferTests.cs index 27b4fec3..4652ce29 100644 --- a/src/tests/ReactiveUI.Primitives.Tests/SignalDeferTests.cs +++ b/src/tests/ReactiveUI.Primitives.Tests/SignalDeferTests.cs @@ -32,11 +32,11 @@ await Assert.That(Signal.FromEnumerable([First, Second]).ToEnumerable().Sequence .IsTrue(); InvalidOperationException factoryError = new("defer-factory"); Exception? observedFactoryError = null; - Signal.Defer(() => throw factoryError).Subscribe(_ => { }, ex => observedFactoryError = ex); + Signal.Defer((Func>)(() => throw factoryError)).Subscribe(_ => { }, ex => observedFactoryError = ex); await Assert.That(observedFactoryError!).IsSameReferenceAs(factoryError); Assert.Throws(() => Signal.Fail(new InvalidOperationException("enumerable")).ToEnumerable()); - Assert.Throws(() => Signal.Defer(null!)); + Assert.Throws(() => Signal.Defer((Func>)null!)); Assert.Throws(() => ((IObservable)null!).ToEnumerable()); } } diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Advanced.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Advanced.cs new file mode 100644 index 00000000..adfc0976 --- /dev/null +++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Advanced.cs @@ -0,0 +1,303 @@ +// Copyright (c) 2019-2026 ReactiveUI Association Incorporated. All rights reserved. +// ReactiveUI Association Incorporated licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using ReactiveUI.Primitives.Advanced; +using ReactiveUI.Primitives.Concurrency; +using ReactiveUI.Primitives.Disposables; +using ReactiveUI.Primitives.Signals; + +namespace ReactiveUI.Primitives.Tests; + +/// Verifies signal operator alias, guard, and coordinator contracts. +public partial class SignalOperatorMixinsTests +{ + /// The first terminal error message. + private const string FirstErrorMessage = "first"; + + /// The late terminal error message. + private const string LateErrorMessage = "late"; + + /// Verifies advanced map-indexed and enumerable blend direct paths. + /// A task representing the asynchronous operation. + [Test] + public async Task AdvancedSignalsReportThreadRequirementsAndBlendUnboundedSources() + { + MapIndexedSignal mapped = new(Signal.Emit(One), static (value, index) => value + index); + RecordingWitness mappedValues = new(); + mapped.Subscribe(mappedValues); + MapIndexedSignal currentThreadMapped = new( + new CurrentThreadObservable(), + static (value, index) => value + index); + MapIndexedSignal optionalThreadMapped = new( + new OptionalCurrentThreadObservable(false), + static (value, index) => value + index); + + List blended = []; + ((IEnumerable>)[Signal.Emit(One), Signal.Emit(Two)]) + .Blend(int.MaxValue) + .Subscribe(blended.Add); + + await Assert.That(mapped.IsRequiredSubscribeOnCurrentThread()).IsFalse(); + await Assert.That(currentThreadMapped.IsRequiredSubscribeOnCurrentThread()).IsTrue(); + await Assert.That(optionalThreadMapped.IsRequiredSubscribeOnCurrentThread()).IsFalse(); + await Assert.That(CurrentThreadRequirement.IsRequired(new ScriptedObservable(_ => { }))).IsFalse(); + await Assert.That(mappedValues.Values.SequenceEqual([One])).IsTrue(); + await Assert.That(mappedValues.Completed).IsEqualTo(1); + await Assert.That(blended.SequenceEqual(ExpectedOneTwo)).IsTrue(); + } + + /// Verifies bounded blend drains enumerable sources and suppresses late terminals. + /// A task representing the asynchronous operation. + [Test] + public async Task MaxConcurrentBlendCoordinatorDrainsAndSuppressesLateTerminals() + { + Signal active = new(); + RecordingWitness drained = new(); + var coordinator = new MaxConcurrentBlendCoordinator(drained).Run([active], Two); + + active.OnNext(One); + active.OnCompleted(); + coordinator.Dispose(); + coordinator.Dispose(); + + await Assert.That(drained.Values.SequenceEqual([One])).IsTrue(); + await Assert.That(drained.Completed).IsEqualTo(1); + + InvalidOperationException first = new(FirstErrorMessage); + InvalidOperationException late = new(LateErrorMessage); + RecordingWitness failed = new(); + new MaxConcurrentBlendCoordinator(failed).Run( + [ + new ScriptedObservable(observer => + { + observer.OnError(first); + observer.OnError(late); + observer.OnCompleted(); + }), + ], + One); + + await Assert.That(failed.Errors.Count).IsEqualTo(1); + await Assert.That(failed.Errors[0]).IsSameReferenceAs(first); + + RecordingWitness nullEnumerator = new(); + new MaxConcurrentBlendCoordinator(nullEnumerator).Run(new NullEnumeratorEnumerable(true), One); + + await Assert.That(nullEnumerator.Completed).IsEqualTo(1); + } + + /// Verifies task-chain coordinators suppress duplicate outer terminal notifications. + /// A task representing the asynchronous operation. + [Test] + public async Task TaskChainCoordinatorSuppressesDuplicateOuterTerminalNotifications() + { + InvalidOperationException first = new(FirstErrorMessage); + InvalidOperationException late = new(LateErrorMessage); + RecordingWitness failed = new(); + + new TaskChainCoordinator(failed).Run(new ScriptedObservable>(observer => + { + observer.OnError(first); + observer.OnError(late); + observer.OnCompleted(); + })); + + await Assert.That(failed.Errors.Count).IsEqualTo(1); + await Assert.That(failed.Errors[0]).IsSameReferenceAs(first); + await Assert.That(failed.Completed).IsEqualTo(0); + + var active = true; + var done = false; + TaskChainCoordinatorState.OnInnerCompleted(new Lock(), ref done, ref active, new TaskChainCoordinator(new RecordingWitness())); + await Assert.That(active).IsFalse(); + + active = true; + done = true; + TaskChainCoordinatorState.OnInnerCompleted(new Lock(), ref done, ref active, new TaskChainCoordinator(new RecordingWitness())); + await Assert.That(active).IsTrue(); + } + + /// Verifies higher-order chain and blend operators reject null inner sources and suppress late errors. + /// A task representing the asynchronous operation. + [Test] + public async Task HigherOrderChainAndBlendHandleNullSourcesAndDuplicateErrors() + { + RecordingWitness chainDisposed = new(); + Signal.Silent>().Chain().Subscribe(chainDisposed).Dispose(); + + RecordingWitness chainNull = new(); + new ScriptedObservable>(observer => observer.OnNext(null!)) + .Chain() + .Subscribe(chainNull); + + RecordingWitness blendNull = new(); + new ScriptedObservable>(observer => observer.OnNext(null!)) + .Blend() + .Subscribe(blendNull); + + InvalidOperationException first = new(FirstErrorMessage); + InvalidOperationException late = new(LateErrorMessage); + RecordingWitness blendErrors = new(); + new ScriptedObservable>(observer => + { + observer.OnError(first); + observer.OnError(late); + }).Blend().Subscribe(blendErrors); + + await Assert.That(chainNull.Errors.Count).IsEqualTo(1); + await Assert.That(chainNull.Errors[0]).IsTypeOf(); + await Assert.That(blendNull.Errors.Count).IsEqualTo(1); + await Assert.That(blendNull.Errors[0]).IsTypeOf(); + await Assert.That(blendErrors.Errors.Count).IsEqualTo(1); + await Assert.That(blendErrors.Errors[0]).IsSameReferenceAs(first); + } + + /// Verifies latch and expire coordinators tolerate non-terminal right completion and duplicate timeouts. + /// A task representing the asynchronous operation. + [Test] + public async Task LatchAndExpireCoordinatorTerminalGuardsAreDeterministic() + { + Signal left = new(); + Signal right = new(); + RecordingWitness latched = new(); + using var latchedSubscription = left.Latch(right, static (leftValue, rightValue) => leftValue + rightValue) + .Subscribe(latched); + + right.OnNext(Two); + right.OnCompleted(); + left.OnNext(Three); + left.OnCompleted(); + + RecordingWitness expired = new(); + Signal.Silent().Expire(TimeSpan.FromTicks(One), new DoubleFireSequencer()).Subscribe(expired); + + await Assert.That(latched.Values.SequenceEqual([Five])).IsTrue(); + await Assert.That(latched.Completed).IsEqualTo(1); + await Assert.That(expired.Errors.Count).IsEqualTo(1); + await Assert.That(expired.Errors[0]).IsTypeOf(); + } + + /// Verifies take-until terminal guards and distinct set creation branches. + /// A task representing the asynchronous operation. + [Test] + public async Task TakeUntilAndDistinctTerminalBranchesAreCovered() + { + RecordingWitness completed = new(); + new ScriptedObservable(observer => + { + observer.OnCompleted(); + observer.OnCompleted(); + }).TakeUntil(Signal.Silent()).Subscribe(completed); + + InvalidOperationException first = new(FirstErrorMessage); + InvalidOperationException late = new(LateErrorMessage); + RecordingWitness failed = new(); + new ScriptedObservable(observer => + { + observer.OnError(first); + observer.OnError(late); + }).TakeUntil(Signal.Silent()).Subscribe(failed); + + RecordingWitness otherFailed = new(); + Signal.Emit(One) + .TakeUntil(new ScriptedObservable(observer => observer.OnError(late))) + .Subscribe(otherFailed); + + RecordingWitness otherCompleted = new(); + Signal.Emit(One) + .TakeUntil(new ScriptedObservable(observer => observer.OnCompleted())) + .Subscribe(otherCompleted); + + List rangeDistinct = []; + Signal.Sequence(One, Three).Distinct().Subscribe(rangeDistinct.Add); + + List comparerDistinct = []; + Signal.FromEnumerable([One, One, Two]) + .Distinct(EqualityComparer.Default) + .Subscribe(comparerDistinct.Add); + + List defaultDistinct = []; + Signal.FromEnumerable([One, One, Two]) + .Distinct() + .Subscribe(defaultDistinct.Add); + + await Assert.That(completed.Completed).IsEqualTo(1); + await Assert.That(failed.Errors.Count).IsEqualTo(1); + await Assert.That(failed.Errors[0]).IsSameReferenceAs(first); + await Assert.That(otherFailed.Errors.Count).IsEqualTo(1); + await Assert.That(otherFailed.Errors[0]).IsSameReferenceAs(late); + await Assert.That(otherCompleted.Values.SequenceEqual([One])).IsTrue(); + await Assert.That(otherCompleted.Completed).IsEqualTo(1); + await Assert.That(rangeDistinct.SequenceEqual([One, Two, Three])).IsTrue(); + await Assert.That(comparerDistinct.SequenceEqual(ExpectedOneTwo)).IsTrue(); + await Assert.That(defaultDistinct.SequenceEqual(ExpectedOneTwo)).IsTrue(); + } + + /// A sequencer that invokes scheduled work twice before returning the disposable work item. + private sealed class DoubleFireSequencer : ISequencer + { + /// + public DateTimeOffset Now => DateTimeOffset.UnixEpoch; + + /// + public long Timestamp => 0; + + /// + public void Schedule(IWorkItem item) + { + item.Execute(); + item.Execute(); + } + + /// + public void Schedule(IWorkItem item, long dueTimestamp) + { + item.Execute(); + item.Execute(); + } + } + + /// An enumerable that returns a null enumerator for defensive coordinator branches. + /// The value type. + private sealed class NullEnumeratorEnumerable : IEnumerable> + { + /// The empty fallback source array. + private static readonly IObservable[] EmptySources = []; + + /// Initializes a new instance of the class. + /// A value indicating whether the enumerable returns a null enumerator. + public NullEnumeratorEnumerable(bool returnNullEnumerator) + { + ReturnNullEnumerator = returnNullEnumerator; + } + + /// Gets a value indicating whether the enumerable returns a null enumerator. + private bool ReturnNullEnumerator { get; } + + /// + public IEnumerator> GetEnumerator() => + ReturnNullEnumerator ? null! : ((IEnumerable>)EmptySources).GetEnumerator(); + + /// + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator(); + } + + /// A source with configurable current-thread subscription requirements. + /// The value type. + private sealed class OptionalCurrentThreadObservable : IRequireCurrentThread + { + /// Initializes a new instance of the class. + /// A value indicating whether current-thread subscription is required. + public OptionalCurrentThreadObservable(bool required) => Required = required; + + /// Gets a value indicating whether current-thread subscription is required. + private bool Required { get; } + + /// + public bool IsRequiredSubscribeOnCurrentThread() => Required; + + /// + public IDisposable Subscribe(IObserver observer) => EmptyDisposable.Instance; + } +} diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Behavior.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Behavior.cs index 9f5a57fc..00bd1446 100644 --- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Behavior.cs +++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.Behavior.cs @@ -451,7 +451,7 @@ private static void CoverParityOperatorNullGuards(IObservable source) /// The non-null object source used for null argument checks. private static void CoverFactoryAndObserverNullGuards(IObservable objects) { - Assert.Throws(() => Signal.Create(null!)); + Assert.Throws(() => Signal.Create((Func, IDisposable>)null!)); Assert.Throws(() => Signal.Lazy(null!)); Assert.Throws(() => Signal.FromEnumerable(null!)); Assert.Throws(() => Signal.FromTask((Task)null!)); diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs index 8bbf054c..792c5d3f 100644 --- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs +++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorMixinsTests.cs @@ -399,6 +399,164 @@ public async Task PrependAppendDefaultIfEmptyFusionPreservesOrderingAndTerminals await Assert.That(emptyPrependValues.SequenceEqual([One, Two, Three, Four, Four])).IsTrue(); } + /// Verifies indexed mapping, task chaining, and task conversion compatibility aliases. + /// A task representing the asynchronous operation. + [Test] + public async Task IndexedMappingTaskChainAndTaskSignalAliasesCoverCompatibilityPaths() + { + Signal source = new(); + RecordingWitness mapped = new(); + using var subscription = LinqExtensions.MapIndexed(source, static (value, index) => value + index) + .Subscribe(mapped); + + source.OnNext(One); + source.OnNext(Three); + source.OnCompleted(); + source.OnNext(Five); + source.OnError(new InvalidOperationException("late")); + + await Assert.That(mapped.Values.SequenceEqual([One, Four])).IsTrue(); + await Assert.That(mapped.Completed).IsEqualTo(1); + await Assert.That(mapped.Errors.Count).IsEqualTo(0); + + RecordingWitness failed = new(); + Signal failing = new(); + using var failingSubscription = LinqExtensions + .MapIndexed(failing, static (_, _) => throw new InvalidOperationException("indexed")) + .Subscribe(failed); + failing.OnNext(One); + failing.OnNext(Two); + + await Assert.That(failed.Values.Count).IsEqualTo(0); + await Assert.That(failed.Errors.Count).IsEqualTo(1); + await Assert.That(failed.Errors[0].Message).IsEqualTo("indexed"); + + RecordingWitness duplicateTerminal = new(); + LinqExtensions.MapIndexed( + new ScriptedObservable(observer => + { + observer.OnNext(One); + observer.OnError(new InvalidOperationException("first")); + observer.OnError(new InvalidOperationException("late")); + observer.OnCompleted(); + }), + static (value, index) => value + index).Subscribe(duplicateTerminal); + + await Assert.That(duplicateTerminal.Values.SequenceEqual([One])).IsTrue(); + await Assert.That(duplicateTerminal.Errors.Count).IsEqualTo(1); + await Assert.That(duplicateTerminal.Errors[0].Message).IsEqualTo("first"); + + RecordingWitness duplicateCompletion = new(); + LinqExtensions.MapIndexed( + new ScriptedObservable(observer => + { + observer.OnCompleted(); + observer.OnCompleted(); + }), + static (value, index) => value + index).Subscribe(duplicateCompletion); + + await Assert.That(duplicateCompletion.Completed).IsEqualTo(1); + + var currentThread = (IRequireCurrentThread)LinqExtensions + .MapIndexed(new CurrentThreadObservable(), static (value, index) => value + index); + await Assert.That(currentThread.IsRequiredSubscribeOnCurrentThread()).IsTrue(); + + List chained = []; + Signal.FromEnumerable([Task.FromResult(One), Task.FromResult(Two)]).Chain().Subscribe(chained.Add); + await Task.Yield(); + + await Assert.That(chained.SequenceEqual(ExpectedOneTwo)).IsTrue(); + + var taskValue = await Task.FromResult(Three).ToSignal().FirstAsync().ConfigureAwait(false); + await Assert.That(taskValue).IsEqualTo(Three); + + Assert.Throws(() => LinqExtensions.MapIndexed(null!, static (value, _) => value)); + Assert.Throws(() => LinqExtensions.MapIndexed(source, null!)); + Assert.Throws(() => ((IObservable>)null!).Chain()); + } + + /// Verifies direct task-chain sequencing without the map adapter. + /// A task representing the asynchronous operation. + [Test] + public async Task TaskChainDirectSignalKeepsPendingTasksInSourceOrder() + { + TaskCompletionSource first = new(TaskCreationOptions.RunContinuationsAsynchronously); + TaskCompletionSource second = new(TaskCreationOptions.RunContinuationsAsynchronously); + Signal> source = new(); + RecordingWitness chained = new(); + + using var subscription = source.Chain().Subscribe(chained); + source.OnNext(first.Task); + source.OnNext(second.Task); + source.OnCompleted(); + + second.SetResult(Two); + await Task.Yield(); + await Assert.That(chained.Values.Count).IsEqualTo(0); + + first.SetResult(One); + await TestPolling.SpinUntil(() => chained.Values.Count == Two && chained.Completed == One, TimeSpan.FromSeconds(One)); + + await Assert.That(chained.Values.SequenceEqual(ExpectedOneTwo)).IsTrue(); + await Assert.That(chained.Errors.Count).IsEqualTo(0); + await Assert.That(chained.Completed).IsEqualTo(One); + } + + /// Verifies direct task-chain terminal and disposal paths. + /// A task representing the asynchronous operation. + [Test] + public async Task TaskChainDirectSignalHandlesErrorsAndDisposal() + { + InvalidOperationException sourceError = new("task-source"); + RecordingWitness sourceFailure = new(); + new ScriptedObservable>(observer => + { + observer.OnError(sourceError); + observer.OnNext(Task.FromResult(One)); + observer.OnCompleted(); + }).Chain().Subscribe(sourceFailure); + + await Assert.That(sourceFailure.Errors.Count).IsEqualTo(One); + await Assert.That(sourceFailure.Errors[0]).IsSameReferenceAs(sourceError); + await Assert.That(sourceFailure.Values.Count).IsEqualTo(0); + await Assert.That(sourceFailure.Completed).IsEqualTo(0); + + RecordingWitness nullTaskFailure = new(); + new ScriptedObservable>(observer => + { + observer.OnNext(null!); + observer.OnCompleted(); + }).Chain().Subscribe(nullTaskFailure); + + await Assert.That(nullTaskFailure.Errors.Count).IsEqualTo(One); + await Assert.That(nullTaskFailure.Errors[0]).IsTypeOf(); + await Assert.That(nullTaskFailure.Completed).IsEqualTo(0); + + InvalidOperationException taskError = new("task"); + RecordingWitness taskFailure = new(); + Signal.FromEnumerable([Task.FromException(taskError), Task.FromResult(One)]).Chain().Subscribe(taskFailure); + + await Assert.That(taskFailure.Errors.Count).IsEqualTo(One); + await Assert.That(taskFailure.Errors[0]).IsSameReferenceAs(taskError); + await Assert.That(taskFailure.Values.Count).IsEqualTo(0); + await Assert.That(taskFailure.Completed).IsEqualTo(0); + + TaskCompletionSource pending = new(TaskCreationOptions.RunContinuationsAsynchronously); + Signal> disposableSource = new(); + RecordingWitness disposed = new(); + using (var disposable = disposableSource.Chain().Subscribe(disposed)) + { + disposableSource.OnNext(pending.Task); + disposable.Dispose(); + pending.SetResult(Five); + } + + await Task.Delay(TimeSpan.FromMilliseconds(50)); + await Assert.That(disposed.Values.Count).IsEqualTo(0); + await Assert.That(disposed.Errors.Count).IsEqualTo(0); + await Assert.That(disposed.Completed).IsEqualTo(0); + } + /// Covers default-if-empty behavior over hot sources for empty, non-empty, error, and observer-guard branches. /// A task representing the asynchronous operation. [Test] @@ -595,4 +753,15 @@ private static void AssertAggregateAndTimingGuards(IObservable source) /// The metric value. /// A value indicating whether the metric is critical. private readonly record struct Metric(long Sequence, double Value, bool IsCritical); + + /// A source that reports current-thread subscription requirements. + /// The value type. + private sealed class CurrentThreadObservable : IRequireCurrentThread + { + /// + public bool IsRequiredSubscribeOnCurrentThread() => true; + + /// + public IDisposable Subscribe(IObserver observer) => EmptyDisposable.Instance; + } } diff --git a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.cs b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.cs index f9d973fd..c6b8f213 100644 --- a/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.cs +++ b/src/tests/ReactiveUI.Primitives.Tests/SignalOperatorParityMixinsTests.cs @@ -4,6 +4,7 @@ using System.Diagnostics.CodeAnalysis; using ReactiveUI.Primitives.Advanced; +using ReactiveUI.Primitives.Concurrency; using ReactiveUI.Primitives.Signals; namespace ReactiveUI.Primitives.Tests; @@ -215,4 +216,62 @@ public async Task TerminalObserversIgnoreLateSignalsAndForwardPredicateFailures( await Assert.That(values).Contains(1L); await Assert.That(values).Contains(true); } + + /// Verifies scheduler-based ToObservable conversion and task conversion aliases. + /// A task representing the asynchronous operation. + [Test] + public async Task ToObservableSchedulerAndTaskAliasesEmitAndHonorCancellation() + { + List immediate = []; + new[] { One, Two }.ToObservable(Sequencer.Immediate).Subscribe(immediate.Add); + + await Assert.That(immediate.SequenceEqual(ExpectedOneTwo)).IsTrue(); + + VirtualClock clock = new(DateTimeOffset.UnixEpoch); + List scheduled = []; + var completed = 0; + new[] { One, Two }.ToObservable(clock).Subscribe(scheduled.Add, ex => throw ex, () => completed++); + clock.Start(); + + await Assert.That(scheduled.SequenceEqual(ExpectedOneTwo)).IsTrue(); + await Assert.That(completed).IsEqualTo(1); + + VirtualClock cancelDuringLoopClock = new(DateTimeOffset.UnixEpoch); + List cancelledDuringLoop = []; + IDisposable? cancelDuringLoopSubscription = null; + cancelDuringLoopSubscription = new[] { One, Two }.ToObservable(cancelDuringLoopClock) + .Subscribe(value => + { + cancelledDuringLoop.Add(value); + cancelDuringLoopSubscription?.Dispose(); + }); + cancelDuringLoopClock.Start(); + + await Assert.That(cancelledDuringLoop.SequenceEqual([One])).IsTrue(); + + VirtualClock cancelBeforeCompletionClock = new(DateTimeOffset.UnixEpoch); + List cancelledBeforeCompletion = []; + var cancelBeforeCompletionCompleted = 0; + IDisposable? cancelBeforeCompletionSubscription = null; + cancelBeforeCompletionSubscription = new[] { One }.ToObservable(cancelBeforeCompletionClock) + .Subscribe( + value => + { + cancelledBeforeCompletion.Add(value); + cancelBeforeCompletionSubscription?.Dispose(); + }, + ex => throw ex, + () => cancelBeforeCompletionCompleted++); + cancelBeforeCompletionClock.Start(); + + await Assert.That(cancelledBeforeCompletion.SequenceEqual([One])).IsTrue(); + await Assert.That(cancelBeforeCompletionCompleted).IsEqualTo(0); + + var taskValue = await Task.FromResult(Three).ToObservable().FirstAsync().ConfigureAwait(false); + await Assert.That(taskValue).IsEqualTo(Three); + + Assert.Throws(() => ((IEnumerable)null!).ToObservable(Sequencer.Immediate)); + Assert.Throws(() => new[] { One }.ToObservable(null!)); + Assert.Throws(() => ((Task)null!).ToObservable()); + } } diff --git a/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/ReactiveUI.Primitives.WinUI.Reactive.Tests.csproj b/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/ReactiveUI.Primitives.WinUI.Reactive.Tests.csproj index 84495f9e..7089b97e 100644 --- a/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/ReactiveUI.Primitives.WinUI.Reactive.Tests.csproj +++ b/src/tests/ReactiveUI.Primitives.WinUI.Reactive.Tests/ReactiveUI.Primitives.WinUI.Reactive.Tests.csproj @@ -27,6 +27,7 @@ true None true + false win-x64 $(DefineConstants);WINDOWS diff --git a/src/tests/ReactiveUI.Primitives.WinUI.Tests/ReactiveUI.Primitives.WinUI.Tests.csproj b/src/tests/ReactiveUI.Primitives.WinUI.Tests/ReactiveUI.Primitives.WinUI.Tests.csproj index dcc110f1..e2d7d097 100644 --- a/src/tests/ReactiveUI.Primitives.WinUI.Tests/ReactiveUI.Primitives.WinUI.Tests.csproj +++ b/src/tests/ReactiveUI.Primitives.WinUI.Tests/ReactiveUI.Primitives.WinUI.Tests.csproj @@ -23,6 +23,7 @@ true None true + false win-x64 $(DefineConstants);WINDOWS diff --git a/tools/generate-publicapi.ps1 b/tools/generate-publicapi.ps1 index 19bd8e05..c1d90322 100644 --- a/tools/generate-publicapi.ps1 +++ b/tools/generate-publicapi.ps1 @@ -53,7 +53,7 @@ param( $ErrorActionPreference = 'Stop' $scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path -$srcDir = (Resolve-Path (Join-Path $scriptDir '..' 'src')).Path +$srcDir = (Resolve-Path (Join-Path (Join-Path $scriptDir '..') 'src')).Path Set-Location $srcDir # MSBuild properties that `dotnet format` cannot accept via -p:; pass through the env