From d11f35324acb865e341d37fa2a78172efed072e6 Mon Sep 17 00:00:00 2001
From: Chris Pulman <chris.pulman@yahoo.com>
Date: Thu, 16 Nov 2023 08:03:00 +0000
Subject: [PATCH] Feature : Add API Tests

---
 .gitignore                                    |    2 +-
 src/DynamicData.Tests/API/ApiApprovalBase.cs  |   43 +
 ...ts.DynamicDataTests.DotNet6_0.verified.txt | 2731 +++++++++++++++++
 src/DynamicData.Tests/API/ApiApprovalTests.cs |   20 +
 .../DynamicData.Tests.csproj                  |    6 +-
 5 files changed, 2799 insertions(+), 3 deletions(-)
 create mode 100644 src/DynamicData.Tests/API/ApiApprovalBase.cs
 create mode 100644 src/DynamicData.Tests/API/ApiApprovalTests.DynamicDataTests.DotNet6_0.verified.txt
 create mode 100644 src/DynamicData.Tests/API/ApiApprovalTests.cs

diff --git a/.gitignore b/.gitignore
index 22729414e..cc0cf38bc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -365,7 +365,7 @@ FodyWeavers.xsd
 .DS_Store	
 
 # API Tests
-src/*.Tests/**/ApiApprovalTests*.received.txt	
+src/*.Tests/API/ApiApprovalTests.*.received.txt
 
 # JetBrains
 .idea/
diff --git a/src/DynamicData.Tests/API/ApiApprovalBase.cs b/src/DynamicData.Tests/API/ApiApprovalBase.cs
new file mode 100644
index 000000000..44b47a6d1
--- /dev/null
+++ b/src/DynamicData.Tests/API/ApiApprovalBase.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using PublicApiGenerator;
+using VerifyXunit;
+
+namespace DynamicData.APITests
+{
+    /// <summary>
+    /// Api Approval Base.
+    /// </summary>
+    [ExcludeFromCodeCoverage]
+    [UsesVerify]
+    public abstract class ApiApprovalBase
+    {
+        /// <summary>
+        /// Check Approval.
+        /// </summary>
+        /// <param name="assembly">The assembly.</param>
+        /// <param name="filePath">The file path.</param>
+        /// <returns>A <see cref="Task"/> representing the result of the asynchronous operation.</returns>
+        protected static Task CheckApproval(Assembly assembly, [CallerFilePath] string? filePath = null)
+        {
+            if (filePath is null)
+            {
+                return Task.CompletedTask;
+            }
+
+            var generatorOptions = new ApiGeneratorOptions { AllowNamespacePrefixes = ["DynamicData"] };
+            var apiText = assembly.GeneratePublicApi(generatorOptions);
+            return Verifier.Verify(apiText, null, filePath)
+                .UniqueForRuntimeAndVersion()
+                .ScrubEmptyLines()
+                .ScrubLines(l =>
+                    l.StartsWith("[assembly: AssemblyVersion(", StringComparison.InvariantCulture) ||
+                    l.StartsWith("[assembly: AssemblyFileVersion(", StringComparison.InvariantCulture) ||
+                    l.StartsWith("[assembly: AssemblyInformationalVersion(", StringComparison.InvariantCulture) ||
+                    l.StartsWith("[assembly: System.Reflection.AssemblyMetadata(", StringComparison.InvariantCulture));
+        }
+    }
+}
diff --git a/src/DynamicData.Tests/API/ApiApprovalTests.DynamicDataTests.DotNet6_0.verified.txt b/src/DynamicData.Tests/API/ApiApprovalTests.DynamicDataTests.DotNet6_0.verified.txt
new file mode 100644
index 000000000..951dd27af
--- /dev/null
+++ b/src/DynamicData.Tests/API/ApiApprovalTests.DynamicDataTests.DotNet6_0.verified.txt
@@ -0,0 +1,2731 @@
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("DynamicData.Profile")]
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("DynamicData.ReactiveUI")]
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("DynamicData.Tests")]
+[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName=".NET 6.0")]
+namespace DynamicData.Aggregation
+{
+    public readonly struct AggregateItem<TObject> : System.IEquatable<DynamicData.Aggregation.AggregateItem<TObject>>
+    {
+        public AggregateItem(DynamicData.Aggregation.AggregateType type, TObject item) { }
+        public TObject Item { get; }
+        public DynamicData.Aggregation.AggregateType Type { get; }
+        public bool Equals(DynamicData.Aggregation.AggregateItem<TObject> other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public static bool operator !=(DynamicData.Aggregation.AggregateItem<TObject> left, DynamicData.Aggregation.AggregateItem<TObject> right) { }
+        public static bool operator ==(DynamicData.Aggregation.AggregateItem<TObject> left, DynamicData.Aggregation.AggregateItem<TObject> right) { }
+    }
+    public enum AggregateType
+    {
+        Add = 0,
+        Remove = 1,
+    }
+    public static class AggregationEx
+    {
+        public static System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<TObject>> ForAggregation<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source)
+            where TObject :  notnull { }
+        public static System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<TObject>> ForAggregation<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<T> InvalidateWhen<T>(this System.IObservable<T> source, System.IObservable<System.Reactive.Unit> invalidate) { }
+        public static System.IObservable<T> InvalidateWhen<T, TTrigger>(this System.IObservable<T> source, System.IObservable<TTrigger?> invalidate) { }
+    }
+    public static class AvgEx
+    {
+        public static System.IObservable<decimal> Avg<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, decimal> valueSelector, [System.Runtime.CompilerServices.DecimalConstant(0, 0, 0u, 0u, 0u)] decimal emptyValue) { }
+        public static System.IObservable<double> Avg<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, double> valueSelector, double emptyValue = 0) { }
+        public static System.IObservable<double> Avg<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, int> valueSelector, int emptyValue = 0) { }
+        public static System.IObservable<double> Avg<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, long> valueSelector, long emptyValue = 0) { }
+        public static System.IObservable<float> Avg<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, float> valueSelector, float emptyValue = 0) { }
+        public static System.IObservable<decimal> Avg<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, decimal?> valueSelector, [System.Runtime.CompilerServices.DecimalConstant(0, 0, 0u, 0u, 0u)] decimal emptyValue) { }
+        public static System.IObservable<double> Avg<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, double?> valueSelector, double emptyValue = 0) { }
+        public static System.IObservable<float> Avg<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, float?> valueSelector, float emptyValue = 0) { }
+        public static System.IObservable<double> Avg<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, int?> valueSelector, int emptyValue = 0) { }
+        public static System.IObservable<double> Avg<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, long?> valueSelector, long emptyValue = 0) { }
+        public static System.IObservable<decimal> Avg<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, decimal> valueSelector, [System.Runtime.CompilerServices.DecimalConstant(0, 0, 0u, 0u, 0u)] decimal emptyValue)
+            where T :  notnull { }
+        public static System.IObservable<double> Avg<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, double> valueSelector, double emptyValue = 0)
+            where T :  notnull { }
+        public static System.IObservable<double> Avg<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, int> valueSelector, int emptyValue = 0)
+            where T :  notnull { }
+        public static System.IObservable<double> Avg<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, long> valueSelector, long emptyValue = 0)
+            where T :  notnull { }
+        public static System.IObservable<float> Avg<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, float> valueSelector, float emptyValue = 0)
+            where T :  notnull { }
+        public static System.IObservable<decimal> Avg<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, decimal?> valueSelector, [System.Runtime.CompilerServices.DecimalConstant(0, 0, 0u, 0u, 0u)] decimal emptyValue)
+            where T :  notnull { }
+        public static System.IObservable<double> Avg<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, double?> valueSelector, double emptyValue = 0)
+            where T :  notnull { }
+        public static System.IObservable<float> Avg<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, float?> valueSelector, float emptyValue = 0)
+            where T :  notnull { }
+        public static System.IObservable<double> Avg<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, int?> valueSelector, int emptyValue = 0)
+            where T :  notnull { }
+        public static System.IObservable<double> Avg<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, long?> valueSelector, long emptyValue = 0)
+            where T :  notnull { }
+        public static System.IObservable<decimal> Avg<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, decimal> valueSelector, [System.Runtime.CompilerServices.DecimalConstant(0, 0, 0u, 0u, 0u)] decimal emptyValue)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<double> Avg<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, double> valueSelector, double emptyValue = 0)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<double> Avg<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, int> valueSelector, int emptyValue = 0)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<double> Avg<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, long> valueSelector, long emptyValue = 0)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<float> Avg<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, float> valueSelector, float emptyValue = 0)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<decimal> Avg<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, decimal?> valueSelector, [System.Runtime.CompilerServices.DecimalConstant(0, 0, 0u, 0u, 0u)] decimal emptyValue)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<double> Avg<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, double?> valueSelector, double emptyValue = 0)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<float> Avg<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, float?> valueSelector, float emptyValue = 0)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<double> Avg<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, int?> valueSelector, int emptyValue = 0)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<double> Avg<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, long?> valueSelector, long emptyValue = 0)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+    public static class CountEx
+    {
+        public static System.IObservable<int> Count<TObject>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<TObject>> source) { }
+        public static System.IObservable<int> Count<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source)
+            where TObject :  notnull { }
+        public static System.IObservable<int> Count<TObject>(this System.IObservable<DynamicData.IDistinctChangeSet<TObject>> source)
+            where TObject :  notnull { }
+        public static System.IObservable<int> Count<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<bool> IsEmpty<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source)
+            where TObject :  notnull { }
+        public static System.IObservable<bool> IsEmpty<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<bool> IsNotEmpty<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source)
+            where TObject :  notnull { }
+        public static System.IObservable<bool> IsNotEmpty<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+    public interface IAggregateChangeSet<T> : System.Collections.Generic.IEnumerable<DynamicData.Aggregation.AggregateItem<T>>, System.Collections.IEnumerable { }
+    public static class MaxEx
+    {
+        public static System.IObservable<TResult> Maximum<TObject, TResult>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Func<TObject, TResult> valueSelector, TResult emptyValue = default)
+            where TObject :  notnull
+            where TResult :  struct, System.IComparable<TResult> { }
+        public static System.IObservable<TResult> Maximum<TObject, TKey, TResult>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TResult> valueSelector, TResult emptyValue = default)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TResult :  struct, System.IComparable<TResult> { }
+        public static System.IObservable<TResult> Minimum<TObject, TResult>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Func<TObject, TResult> valueSelector, TResult emptyValue = default)
+            where TObject :  notnull
+            where TResult :  struct, System.IComparable<TResult> { }
+        public static System.IObservable<TResult> Minimum<TObject, TKey, TResult>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TResult> valueSelector, TResult emptyValue = default)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TResult :  struct, System.IComparable<TResult> { }
+    }
+    public static class StdDevEx
+    {
+        public static System.IObservable<double> StdDev<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, decimal> valueSelector, [System.Runtime.CompilerServices.DecimalConstant(0, 0, 0u, 0u, 0u)] decimal fallbackValue) { }
+        public static System.IObservable<double> StdDev<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, double> valueSelector, double fallbackValue = 0) { }
+        public static System.IObservable<double> StdDev<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, int> valueSelector, int fallbackValue = 0) { }
+        public static System.IObservable<double> StdDev<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, long> valueSelector, long fallbackValue = 0) { }
+        public static System.IObservable<double> StdDev<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, float> valueSelector, float fallbackValue = 0) { }
+        public static System.IObservable<double> StdDev<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, decimal> valueSelector, decimal fallbackValue)
+            where T :  notnull { }
+        public static System.IObservable<double> StdDev<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, double> valueSelector, double fallbackValue)
+            where T :  notnull { }
+        public static System.IObservable<double> StdDev<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, int> valueSelector, int fallbackValue)
+            where T :  notnull { }
+        public static System.IObservable<double> StdDev<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, long> valueSelector, long fallbackValue)
+            where T :  notnull { }
+        public static System.IObservable<double> StdDev<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, float> valueSelector, float fallbackValue = 0)
+            where T :  notnull { }
+        public static System.IObservable<double> StdDev<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, decimal> valueSelector, decimal fallbackValue)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<double> StdDev<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, double> valueSelector, double fallbackValue)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<double> StdDev<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, int> valueSelector, int fallbackValue)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<double> StdDev<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, long> valueSelector, long fallbackValue)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<double> StdDev<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, float> valueSelector, float fallbackValue = 0)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+    public static class SumEx
+    {
+        public static System.IObservable<decimal> Sum<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, decimal> valueSelector) { }
+        public static System.IObservable<double> Sum<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, double> valueSelector) { }
+        public static System.IObservable<int> Sum<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, int> valueSelector) { }
+        public static System.IObservable<long> Sum<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, long> valueSelector) { }
+        public static System.IObservable<float> Sum<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, float> valueSelector) { }
+        public static System.IObservable<decimal> Sum<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, decimal?> valueSelector) { }
+        public static System.IObservable<double> Sum<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, double?> valueSelector) { }
+        public static System.IObservable<float> Sum<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, float?> valueSelector) { }
+        public static System.IObservable<int> Sum<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, int?> valueSelector) { }
+        public static System.IObservable<long> Sum<T>(this System.IObservable<DynamicData.Aggregation.IAggregateChangeSet<T>> source, System.Func<T, long?> valueSelector) { }
+        public static System.IObservable<decimal> Sum<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, decimal> valueSelector)
+            where T :  notnull { }
+        public static System.IObservable<double> Sum<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, double> valueSelector)
+            where T :  notnull { }
+        public static System.IObservable<int> Sum<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, int> valueSelector)
+            where T :  notnull { }
+        public static System.IObservable<long> Sum<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, long> valueSelector)
+            where T :  notnull { }
+        public static System.IObservable<float> Sum<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, float> valueSelector)
+            where T :  notnull { }
+        public static System.IObservable<decimal> Sum<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, decimal?> valueSelector)
+            where T :  notnull { }
+        public static System.IObservable<double> Sum<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, double?> valueSelector)
+            where T :  notnull { }
+        public static System.IObservable<float> Sum<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, float?> valueSelector)
+            where T :  notnull { }
+        public static System.IObservable<int> Sum<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, int?> valueSelector)
+            where T :  notnull { }
+        public static System.IObservable<long> Sum<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, long?> valueSelector)
+            where T :  notnull { }
+        public static System.IObservable<decimal> Sum<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, decimal> valueSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<double> Sum<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, double> valueSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<int> Sum<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, int> valueSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<long> Sum<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, long> valueSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<float> Sum<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, float> valueSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<decimal> Sum<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, decimal?> valueSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<double> Sum<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, double?> valueSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<float> Sum<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, float?> valueSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<int> Sum<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, int?> valueSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<long> Sum<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, long?> valueSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+}
+namespace DynamicData.Alias
+{
+    public static class ObservableCacheAlias
+    {
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Select<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, System.IObservable<System.Reactive.Unit> forceTransform)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Select<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, System.IObservable<System.Func<TSource, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Select<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, TDestination> transformFactory, System.IObservable<System.Reactive.Unit> forceTransform)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Select<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, TDestination> transformFactory, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> SelectMany<TDestination, TDestinationKey, TSource, TSourceKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TSourceKey>> source, System.Func<TSource, System.Collections.Generic.IEnumerable<TDestination>> manySelector, System.Func<TDestination, TDestinationKey> keySelector)
+            where TDestination :  notnull
+            where TDestinationKey :  notnull
+            where TSource :  notnull
+            where TSourceKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> SelectSafe<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Reactive.Unit> forceTransform)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> SelectSafe<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Func<TSource, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> SelectSafe<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, TDestination> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Reactive.Unit> forceTransform)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> SelectSafe<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, TDestination> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<DynamicData.Node<TObject, TKey>, TKey>> SelectTree<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey> pivotOn)
+            where TObject :  class
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Where<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, bool> filter)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Where<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<System.Func<TObject, bool>> predicateChanged)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Where<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<System.Reactive.Unit> reapplyFilter)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Where<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<System.Func<TObject, bool>> predicateChanged, System.IObservable<System.Reactive.Unit> reapplyFilter)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+    public static class ObservableListAlias
+    {
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> Select<TSource, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, TDestination> transformFactory)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> SelectMany<TDestination, TSource>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, System.Collections.Generic.IEnumerable<TDestination>> manySelector)
+            where TDestination :  notnull
+            where TSource :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Where<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, bool> predicate)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Where<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.IObservable<System.Func<T, bool>> predicate)
+            where T :  notnull { }
+    }
+}
+namespace DynamicData.Binding
+{
+    public abstract class AbstractNotifyPropertyChanged : System.ComponentModel.INotifyPropertyChanged
+    {
+        protected AbstractNotifyPropertyChanged() { }
+        public event System.ComponentModel.PropertyChangedEventHandler? PropertyChanged;
+        protected virtual void OnPropertyChanged([System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null) { }
+        protected virtual void SetAndRaise<T>(ref T backingField, T newValue, [System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null) { }
+        protected virtual void SetAndRaise<T>(ref T backingField, T newValue, System.Collections.Generic.IEqualityComparer<T>? comparer, [System.Runtime.CompilerServices.CallerMemberName] string? propertyName = null) { }
+        [System.Obsolete("This never worked properly in the first place")]
+        public System.IDisposable SuspendNotifications(bool invokePropertyChangeEventWhenDisposed = true) { }
+    }
+    public class BindingListAdaptor<T> : DynamicData.IChangeSetAdaptor<T>
+        where T :  notnull
+    {
+        public BindingListAdaptor(System.ComponentModel.BindingList<T> list, int refreshThreshold = 25) { }
+        public void Adapt(DynamicData.IChangeSet<T> changes) { }
+    }
+    public class BindingListAdaptor<TObject, TKey> : DynamicData.IChangeSetAdaptor<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public BindingListAdaptor(System.ComponentModel.BindingList<TObject> list, int refreshThreshold = 25) { }
+        public void Adapt(DynamicData.IChangeSet<TObject, TKey> changes) { }
+    }
+    public static class BindingListEx
+    {
+        public static System.IObservable<System.Reactive.EventPattern<System.ComponentModel.ListChangedEventArgs>> ObserveCollectionChanges(this System.ComponentModel.IBindingList source) { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<T>(this System.ComponentModel.BindingList<T> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<TCollection, T>(this TCollection source)
+            where TCollection : System.ComponentModel.IBindingList, System.Collections.Generic.IEnumerable<T>
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> ToObservableChangeSet<TObject, TKey>(this System.ComponentModel.BindingList<TObject> source, System.Func<TObject, TKey> keySelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+    public interface IEvaluateAware
+    {
+        void Evaluate();
+    }
+    public interface IIndexAware
+    {
+        int Index { get; set; }
+    }
+    public interface INotifyCollectionChangedSuspender
+    {
+        System.IDisposable SuspendCount();
+        System.IDisposable SuspendNotifications();
+    }
+    public interface IObservableCollectionAdaptor<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        void Adapt(DynamicData.IChangeSet<TObject, TKey> changes, DynamicData.Binding.IObservableCollection<TObject> collection);
+    }
+    public interface IObservableCollection<T> : DynamicData.Binding.INotifyCollectionChangedSuspender, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.IEnumerable, System.Collections.Specialized.INotifyCollectionChanged, System.ComponentModel.INotifyPropertyChanged
+    {
+        void Load(System.Collections.Generic.IEnumerable<T> items);
+        void Move(int oldIndex, int newIndex);
+    }
+    public static class IObservableListEx
+    {
+        public static System.IObservable<DynamicData.IChangeSet<TObject>> BindToObservableList<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, out DynamicData.IObservableList<TObject> observableList)
+            where TObject :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> BindToObservableList<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, out DynamicData.IObservableList<TObject> observableList)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> BindToObservableList<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source, out DynamicData.IObservableList<TObject> observableList)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+    public interface ISortedObservableCollectionAdaptor<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        void Adapt(DynamicData.ISortedChangeSet<TObject, TKey> changes, DynamicData.Binding.IObservableCollection<TObject> collection);
+    }
+    public static class NotifyPropertyChangedEx
+    {
+        public static System.IObservable<TObject?> WhenAnyPropertyChanged<TObject>(this TObject source, params string[] propertiesToMonitor)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<TResult?> WhenChanged<TObject, TResult, TProperty1>(this TObject source, System.Linq.Expressions.Expression<System.Func<TObject, TProperty1>> p1, System.Func<TObject, TProperty1?, TResult> resultSelector, System.Func<TProperty1>? p1Fallback = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<TResult?> WhenChanged<TObject, TResult, TProperty1, TProperty2>(this TObject source, System.Linq.Expressions.Expression<System.Func<TObject, TProperty1>> p1, System.Linq.Expressions.Expression<System.Func<TObject, TProperty2>> p2, System.Func<TObject, TProperty1?, TProperty2?, TResult> resultSelector, System.Func<TProperty1>? p1Fallback = null, System.Func<TProperty2>? p2Fallback = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<TResult?> WhenChanged<TObject, TResult, TProperty1, TProperty2, TProperty3>(this TObject source, System.Linq.Expressions.Expression<System.Func<TObject, TProperty1>> p1, System.Linq.Expressions.Expression<System.Func<TObject, TProperty2>> p2, System.Linq.Expressions.Expression<System.Func<TObject, TProperty3>> p3, System.Func<TObject, TProperty1?, TProperty2?, TProperty3?, TResult> resultSelector, System.Func<TProperty1>? p1Fallback = null, System.Func<TProperty2>? p2Fallback = null, System.Func<TProperty3>? p3Fallback = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<TResult?> WhenChanged<TObject, TResult, TProperty1, TProperty2, TProperty3, TProperty4>(this TObject source, System.Linq.Expressions.Expression<System.Func<TObject, TProperty1>> p1, System.Linq.Expressions.Expression<System.Func<TObject, TProperty2>> p2, System.Linq.Expressions.Expression<System.Func<TObject, TProperty3>> p3, System.Linq.Expressions.Expression<System.Func<TObject, TProperty4>> p4, System.Func<TObject, TProperty1?, TProperty2?, TProperty3?, TProperty4?, TResult> resultSelector, System.Func<TProperty1>? p1Fallback = null, System.Func<TProperty2>? p2Fallback = null, System.Func<TProperty3>? p3Fallback = null, System.Func<TProperty4>? p4Fallback = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<TResult?> WhenChanged<TObject, TResult, TProperty1, TProperty2, TProperty3, TProperty4, TProperty5>(this TObject source, System.Linq.Expressions.Expression<System.Func<TObject, TProperty1>> p1, System.Linq.Expressions.Expression<System.Func<TObject, TProperty2>> p2, System.Linq.Expressions.Expression<System.Func<TObject, TProperty3>> p3, System.Linq.Expressions.Expression<System.Func<TObject, TProperty4>> p4, System.Linq.Expressions.Expression<System.Func<TObject, TProperty5>> p5, System.Func<TObject, TProperty1?, TProperty2?, TProperty3?, TProperty4?, TProperty5?, TResult> resultSelector, System.Func<TProperty1>? p1Fallback = null, System.Func<TProperty2>? p2Fallback = null, System.Func<TProperty3>? p3Fallback = null, System.Func<TProperty4>? p4Fallback = null, System.Func<TProperty5>? p5Fallback = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<TResult?> WhenChanged<TObject, TResult, TProperty1, TProperty2, TProperty3, TProperty4, TProperty5, TProperty6>(this TObject source, System.Linq.Expressions.Expression<System.Func<TObject, TProperty1>> p1, System.Linq.Expressions.Expression<System.Func<TObject, TProperty2>> p2, System.Linq.Expressions.Expression<System.Func<TObject, TProperty3>> p3, System.Linq.Expressions.Expression<System.Func<TObject, TProperty4>> p4, System.Linq.Expressions.Expression<System.Func<TObject, TProperty5>> p5, System.Linq.Expressions.Expression<System.Func<TObject, TProperty6>> p6, System.Func<TObject, TProperty1?, TProperty2?, TProperty3?, TProperty4?, TProperty5?, TProperty6?, TResult> resultSelector, System.Func<TProperty1>? p1Fallback = null, System.Func<TProperty2>? p2Fallback = null, System.Func<TProperty3>? p3Fallback = null, System.Func<TProperty4>? p4Fallback = null, System.Func<TProperty5>? p5Fallback = null, System.Func<TProperty6>? p6Fallback = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<DynamicData.Binding.PropertyValue<TObject, TProperty>> WhenPropertyChanged<TObject, TProperty>(this TObject source, System.Linq.Expressions.Expression<System.Func<TObject, TProperty>> propertyAccessor, bool notifyOnInitialValue = true, System.Func<TProperty?>? fallbackValue = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<TProperty?> WhenValueChanged<TObject, TProperty>(this TObject source, System.Linq.Expressions.Expression<System.Func<TObject, TProperty>> propertyAccessor, bool notifyOnInitialValue = true, System.Func<TProperty>? fallbackValue = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+    }
+    public class ObservableCollectionAdaptor<T> : DynamicData.IChangeSetAdaptor<T>
+        where T :  notnull
+    {
+        public ObservableCollectionAdaptor(DynamicData.Binding.IObservableCollection<T> collection, int refreshThreshold = 25) { }
+        public void Adapt(DynamicData.IChangeSet<T> changes) { }
+    }
+    public class ObservableCollectionAdaptor<TObject, TKey> : DynamicData.Binding.IObservableCollectionAdaptor<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public ObservableCollectionAdaptor(int refreshThreshold = 25, bool useReplaceForUpdates = false) { }
+        public void Adapt(DynamicData.IChangeSet<TObject, TKey> changes, DynamicData.Binding.IObservableCollection<TObject> collection) { }
+    }
+    public static class ObservableCollectionEx
+    {
+        public static System.IObservable<System.Reactive.EventPattern<System.Collections.Specialized.NotifyCollectionChangedEventArgs>> ObserveCollectionChanges(this System.Collections.Specialized.INotifyCollectionChanged source) { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<T>(this System.Collections.ObjectModel.ObservableCollection<T> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<T>(this System.Collections.ObjectModel.ReadOnlyObservableCollection<T> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<TCollection, T>(this TCollection source)
+            where TCollection : System.Collections.Specialized.INotifyCollectionChanged, System.Collections.Generic.IEnumerable<T>
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> ToObservableChangeSet<TObject, TKey>(this System.Collections.ObjectModel.ObservableCollection<TObject> source, System.Func<TObject, TKey> keySelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> ToObservableChangeSet<TObject, TKey>(this System.Collections.ObjectModel.ReadOnlyObservableCollection<TObject> source, System.Func<TObject, TKey> keySelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+    public class ObservableCollectionExtended<T> : System.Collections.ObjectModel.ObservableCollection<T>, DynamicData.Binding.INotifyCollectionChangedSuspender, DynamicData.Binding.IObservableCollection<T>, DynamicData.IExtendedList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.IEnumerable, System.Collections.Specialized.INotifyCollectionChanged, System.ComponentModel.INotifyPropertyChanged
+    {
+        public ObservableCollectionExtended() { }
+        public ObservableCollectionExtended(System.Collections.Generic.IEnumerable<T> collection) { }
+        public ObservableCollectionExtended(System.Collections.Generic.List<T> list) { }
+        public void AddRange(System.Collections.Generic.IEnumerable<T> collection) { }
+        public void InsertRange(System.Collections.Generic.IEnumerable<T> collection, int index) { }
+        public void Load(System.Collections.Generic.IEnumerable<T> items) { }
+        protected override void OnCollectionChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs e) { }
+        protected override void OnPropertyChanged(System.ComponentModel.PropertyChangedEventArgs e) { }
+        public void RemoveRange(int index, int count) { }
+        public System.IDisposable SuspendCount() { }
+        public System.IDisposable SuspendNotifications() { }
+    }
+    public sealed class PropertyValue<TObject, TValue> : System.IEquatable<DynamicData.Binding.PropertyValue<TObject, TValue>>
+    {
+        public PropertyValue(TObject sender, TValue value) { }
+        public TObject Sender { get; }
+        public TValue Value { get; }
+        public bool Equals(DynamicData.Binding.PropertyValue<TObject, TValue>? other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+        public static bool operator !=(DynamicData.Binding.PropertyValue<TObject, TValue>? left, DynamicData.Binding.PropertyValue<TObject, TValue>? right) { }
+        public static bool operator ==(DynamicData.Binding.PropertyValue<TObject, TValue>? left, DynamicData.Binding.PropertyValue<TObject, TValue>? right) { }
+    }
+    public enum SortDirection
+    {
+        Ascending = 0,
+        Descending = 1,
+    }
+    public class SortExpressionComparer<T> : System.Collections.Generic.List<DynamicData.Binding.SortExpression<T>>, System.Collections.Generic.IComparer<T>
+    {
+        public SortExpressionComparer() { }
+        public int Compare(T? x, T? y) { }
+        public DynamicData.Binding.SortExpressionComparer<T> ThenByAscending(System.Func<T, System.IComparable> expression) { }
+        public DynamicData.Binding.SortExpressionComparer<T> ThenByDescending(System.Func<T, System.IComparable> expression) { }
+        public static DynamicData.Binding.SortExpressionComparer<T> Ascending(System.Func<T, System.IComparable> expression) { }
+        public static DynamicData.Binding.SortExpressionComparer<T> Descending(System.Func<T, System.IComparable> expression) { }
+    }
+    public class SortExpression<T>
+    {
+        public SortExpression(System.Func<T, System.IComparable> expression, DynamicData.Binding.SortDirection direction = 0) { }
+        public DynamicData.Binding.SortDirection Direction { get; }
+        public System.Func<T, System.IComparable> Expression { get; }
+    }
+    public class SortedBindingListAdaptor<TObject, TKey> : DynamicData.ISortedChangeSetAdaptor<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public SortedBindingListAdaptor(System.ComponentModel.BindingList<TObject> list, int refreshThreshold = 25) { }
+        public void Adapt(DynamicData.ISortedChangeSet<TObject, TKey> changes) { }
+    }
+    public class SortedObservableCollectionAdaptor<TObject, TKey> : DynamicData.Binding.ISortedObservableCollectionAdaptor<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public SortedObservableCollectionAdaptor(int refreshThreshold = 25, bool useReplaceForUpdates = true) { }
+        public void Adapt(DynamicData.ISortedChangeSet<TObject, TKey> changes, DynamicData.Binding.IObservableCollection<TObject> collection) { }
+    }
+}
+namespace DynamicData.Cache.Internal
+{
+    public enum CombineOperator
+    {
+        And = 0,
+        Or = 1,
+        Xor = 2,
+        Except = 3,
+    }
+    [System.Serializable]
+    public class KeySelectorException : System.Exception
+    {
+        public KeySelectorException() { }
+        public KeySelectorException(string message) { }
+        protected KeySelectorException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+        public KeySelectorException(string message, System.Exception innerException) { }
+    }
+    [System.Diagnostics.DebuggerDisplay("LockFreeObservableCache<{typeof(TObject).Name}, {typeof(TKey).Name}> ({Count} Ite" +
+        "ms)")]
+    public sealed class LockFreeObservableCache<TObject, TKey> : DynamicData.IConnectableCache<TObject, TKey>, DynamicData.IObservableCache<TObject, TKey>, System.IDisposable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public LockFreeObservableCache() { }
+        public LockFreeObservableCache(System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source) { }
+        public int Count { get; }
+        public System.IObservable<int> CountChanged { get; }
+        public System.Collections.Generic.IEnumerable<TObject> Items { get; }
+        public System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>> KeyValues { get; }
+        public System.Collections.Generic.IEnumerable<TKey> Keys { get; }
+        public System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Connect(System.Func<TObject, bool>? predicate = null, bool suppressEmptyChangeSets = true) { }
+        public void Dispose() { }
+        public void Edit(System.Action<DynamicData.ICacheUpdater<TObject, TKey>> editAction) { }
+        public DynamicData.Kernel.Optional<TObject> Lookup(TKey key) { }
+        public System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Preview(System.Func<TObject, bool>? predicate = null) { }
+        public System.IObservable<DynamicData.Change<TObject, TKey>> Watch(TKey key) { }
+    }
+}
+namespace DynamicData
+{
+    public sealed class ChangeAwareCache<TObject, TKey> : DynamicData.ICache<TObject, TKey>, DynamicData.IQuery<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public ChangeAwareCache() { }
+        public ChangeAwareCache(System.Collections.Generic.Dictionary<TKey, TObject> data) { }
+        public ChangeAwareCache(int capacity) { }
+        public int Count { get; }
+        public System.Collections.Generic.IEnumerable<TObject> Items { get; }
+        public System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>> KeyValues { get; }
+        public System.Collections.Generic.IEnumerable<TKey> Keys { get; }
+        public void Add(TObject item, TKey key) { }
+        public void AddOrUpdate(TObject item, TKey key) { }
+        public DynamicData.ChangeSet<TObject, TKey> CaptureChanges() { }
+        public void Clear() { }
+        public void Clone(DynamicData.IChangeSet<TObject, TKey> changes) { }
+        public DynamicData.Kernel.Optional<TObject> Lookup(TKey key) { }
+        public void Refresh() { }
+        public void Refresh(System.Collections.Generic.IEnumerable<TKey> keys) { }
+        public void Refresh(TKey key) { }
+        public void Remove(System.Collections.Generic.IEnumerable<TKey> keys) { }
+        public void Remove(TKey key) { }
+    }
+    public class ChangeAwareList<T> : DynamicData.IExtendedList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.IEnumerable
+        where T :  notnull
+    {
+        public ChangeAwareList(System.Collections.Generic.IEnumerable<T> items) { }
+        public ChangeAwareList(int capacity = -1) { }
+        public ChangeAwareList(DynamicData.ChangeAwareList<T> list, bool copyChanges) { }
+        public int Capacity { get; set; }
+        public int Count { get; }
+        public bool IsReadOnly { get; }
+        public T this[int index] { get; set; }
+        public void Add(T item) { }
+        public void AddRange(System.Collections.Generic.IEnumerable<T> collection) { }
+        public DynamicData.IChangeSet<T> CaptureChanges() { }
+        public virtual void Clear() { }
+        public virtual bool Contains(T item) { }
+        public void CopyTo(T[] array, int arrayIndex) { }
+        public System.Collections.Generic.IEnumerator<T> GetEnumerator() { }
+        public int IndexOf(T item) { }
+        public int IndexOf(T item, System.Collections.Generic.IEqualityComparer<T> equalityComparer) { }
+        public void Insert(int index, T item) { }
+        protected virtual void InsertItem(int index, T item) { }
+        public void InsertRange(System.Collections.Generic.IEnumerable<T> collection, int index) { }
+        public virtual void Move(int original, int destination) { }
+        public virtual void Move(T item, int destination) { }
+        protected virtual void OnInsertItems(int startIndex, System.Collections.Generic.IEnumerable<T> items) { }
+        protected virtual void OnRemoveItems(int startIndex, System.Collections.Generic.IEnumerable<T> items) { }
+        protected virtual void OnSetItem(int index, T newItem, T oldItem) { }
+        public bool Refresh(T item) { }
+        public void Refresh(T item, int index) { }
+        public void RefreshAt(int index) { }
+        public bool Remove(T item) { }
+        public void RemoveAt(int index) { }
+        protected void RemoveItem(int index) { }
+        protected virtual void RemoveItem(int index, T item) { }
+        public void RemoveRange(int index, int count) { }
+        protected virtual void SetItem(int index, T item) { }
+    }
+    public enum ChangeReason
+    {
+        Add = 0,
+        Update = 1,
+        Remove = 2,
+        Refresh = 3,
+        Moved = 4,
+    }
+    public static class ChangeSetEx
+    {
+        public static System.Collections.Generic.IEnumerable<DynamicData.ItemChange<T>> Flatten<T>(this DynamicData.IChangeSet<T> source)
+            where T :  notnull { }
+        public static DynamicData.ChangeType GetChangeType(this DynamicData.ListChangeReason source) { }
+        public static DynamicData.IChangeSet<TDestination> Transform<TSource, TDestination>(this DynamicData.IChangeSet<TSource> source, System.Func<TSource, TDestination> transformer)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.Collections.Generic.IEnumerable<DynamicData.Change<T>> YieldWithoutIndex<T>(this System.Collections.Generic.IEnumerable<DynamicData.Change<T>> source)
+            where T :  notnull { }
+    }
+    public class ChangeSet<T> : System.Collections.Generic.List<DynamicData.Change<T>>, DynamicData.IChangeSet, DynamicData.IChangeSet<T>, System.Collections.Generic.IEnumerable<DynamicData.Change<T>>, System.Collections.IEnumerable
+        where T :  notnull
+    {
+        public static readonly DynamicData.IChangeSet<T> Empty;
+        public ChangeSet() { }
+        public ChangeSet(System.Collections.Generic.IEnumerable<DynamicData.Change<T>> items) { }
+        public int Adds { get; }
+        public int Moves { get; }
+        public int Refreshes { get; }
+        public int Removes { get; }
+        public int Replaced { get; }
+        public int TotalChanges { get; }
+        public override string ToString() { }
+    }
+    public class ChangeSet<TObject, TKey> : System.Collections.Generic.List<DynamicData.Change<TObject, TKey>>, DynamicData.IChangeSet, DynamicData.IChangeSet<TObject, TKey>, System.Collections.Generic.IEnumerable<DynamicData.Change<TObject, TKey>>, System.Collections.IEnumerable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public static readonly DynamicData.ChangeSet<TObject, TKey> Empty;
+        public ChangeSet() { }
+        public ChangeSet(System.Collections.Generic.IEnumerable<DynamicData.Change<TObject, TKey>> collection) { }
+        public ChangeSet(int capacity) { }
+        public int Adds { get; }
+        public int Moves { get; }
+        public int Refreshes { get; }
+        public int Removes { get; }
+        public int Updates { get; }
+        public override string ToString() { }
+    }
+    public enum ChangeType
+    {
+        Item = 0,
+        Range = 1,
+    }
+    public sealed class Change<T> : System.IEquatable<DynamicData.Change<T>>
+        where T :  notnull
+    {
+        public Change(DynamicData.ListChangeReason reason, System.Collections.Generic.IEnumerable<T> items, int index = -1) { }
+        public Change(DynamicData.ListChangeReason reason, T current, int index = -1) { }
+        public Change(T current, int currentIndex, int previousIndex) { }
+        public Change(DynamicData.ListChangeReason reason, T current, DynamicData.Kernel.Optional<T> previous, int currentIndex = -1, int previousIndex = -1) { }
+        public DynamicData.ItemChange<T> Item { get; }
+        public DynamicData.RangeChange<T> Range { get; }
+        public DynamicData.ListChangeReason Reason { get; }
+        public DynamicData.ChangeType Type { get; }
+        public bool Equals(DynamicData.Change<T>? other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+        public static bool operator !=(DynamicData.Change<T> left, DynamicData.Change<T> right) { }
+        public static bool operator ==(DynamicData.Change<T> left, DynamicData.Change<T> right) { }
+    }
+    public readonly struct Change<TObject, TKey> : System.IEquatable<DynamicData.Change<TObject, TKey>>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public Change(DynamicData.ChangeReason reason, TKey key, TObject current, int index = -1) { }
+        public Change(TKey key, TObject current, int currentIndex, int previousIndex) { }
+        public Change(DynamicData.ChangeReason reason, TKey key, TObject current, DynamicData.Kernel.Optional<TObject> previous, int currentIndex = -1, int previousIndex = -1) { }
+        public TObject Current { get; }
+        public int CurrentIndex { get; }
+        public TKey Key { get; }
+        public DynamicData.Kernel.Optional<TObject> Previous { get; }
+        public int PreviousIndex { get; }
+        public DynamicData.ChangeReason Reason { get; }
+        public bool Equals(DynamicData.Change<TObject, TKey> other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+        public static bool operator !=(DynamicData.Change<TObject, TKey> left, DynamicData.Change<TObject, TKey> right) { }
+        public static bool operator ==(DynamicData.Change<TObject, TKey> left, DynamicData.Change<TObject, TKey> right) { }
+    }
+    public static class EnumerableEx
+    {
+        public static System.IObservable<DynamicData.IChangeSet<TObject>> AsObservableChangeSet<TObject>(this System.Collections.Generic.IEnumerable<TObject> source, bool completable = false)
+            where TObject :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> AsObservableChangeSet<TObject, TKey>(this System.Collections.Generic.IEnumerable<TObject> source, System.Func<TObject, TKey> keySelector, bool completable = false)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+    public interface ICacheUpdater<TObject, TKey> : DynamicData.IQuery<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        void AddOrUpdate(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>> keyValuePairs);
+        void AddOrUpdate(System.Collections.Generic.KeyValuePair<TKey, TObject> item);
+        void AddOrUpdate(TObject item, TKey key);
+        void Clear();
+        void Clone(DynamicData.IChangeSet<TObject, TKey> changes);
+        [System.Obsolete("Use Refresh: Same thing but better semantics")]
+        void Evaluate();
+        [System.Obsolete("Use Refresh: Same thing but better semantics")]
+        void Evaluate(System.Collections.Generic.IEnumerable<TKey> keys);
+        [System.Obsolete("Use Refresh: Same thing but better semantics")]
+        void Evaluate(TKey key);
+        TKey GetKey(TObject item);
+        System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>> GetKeyValues(System.Collections.Generic.IEnumerable<TObject> items);
+        void Refresh();
+        void Refresh(System.Collections.Generic.IEnumerable<TKey> keys);
+        void Refresh(TKey key);
+        void Remove(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>> items);
+        void Remove(System.Collections.Generic.IEnumerable<TKey> keys);
+        void Remove(System.Collections.Generic.KeyValuePair<TKey, TObject> item);
+        void Remove(TKey key);
+        void RemoveKey(TKey key);
+        void RemoveKeys(System.Collections.Generic.IEnumerable<TKey> key);
+        [System.Obsolete("Use Clone()")]
+        void Update(DynamicData.IChangeSet<TObject, TKey> changes);
+    }
+    public interface ICache<TObject, TKey> : DynamicData.IQuery<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        void AddOrUpdate(TObject item, TKey key);
+        void Clear();
+        void Clone(DynamicData.IChangeSet<TObject, TKey> changes);
+        void Refresh();
+        void Refresh(System.Collections.Generic.IEnumerable<TKey> keys);
+        void Refresh(TKey key);
+        void Remove(System.Collections.Generic.IEnumerable<TKey> keys);
+        void Remove(TKey key);
+    }
+    public interface IChangeSet
+    {
+        int Adds { get; }
+        int Capacity { get; set; }
+        int Count { get; }
+        int Moves { get; }
+        int Refreshes { get; }
+        int Removes { get; }
+    }
+    public interface IChangeSetAdaptor<T>
+        where T :  notnull
+    {
+        void Adapt(DynamicData.IChangeSet<T> change);
+    }
+    public interface IChangeSetAdaptor<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        void Adapt(DynamicData.IChangeSet<TObject, TKey> change);
+    }
+    public interface IChangeSet<TObject> : DynamicData.IChangeSet, System.Collections.Generic.IEnumerable<DynamicData.Change<TObject>>, System.Collections.IEnumerable
+        where TObject :  notnull
+    {
+        int Replaced { get; }
+        int TotalChanges { get; }
+    }
+    public interface IChangeSet<TObject, TKey> : DynamicData.IChangeSet, System.Collections.Generic.IEnumerable<DynamicData.Change<TObject, TKey>>, System.Collections.IEnumerable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        int Updates { get; }
+    }
+    public interface IConnectableCache<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        System.IObservable<int> CountChanged { get; }
+        System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Connect(System.Func<TObject, bool>? predicate = null, bool suppressEmptyChangeSets = true);
+        System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Preview(System.Func<TObject, bool>? predicate = null);
+        System.IObservable<DynamicData.Change<TObject, TKey>> Watch(TKey key);
+    }
+    public interface IDistinctChangeSet<T> : DynamicData.IChangeSet, DynamicData.IChangeSet<T, T>, System.Collections.Generic.IEnumerable<DynamicData.Change<T, T>>, System.Collections.IEnumerable
+        where T :  notnull { }
+    public interface IExtendedList<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.IEnumerable
+    {
+        void AddRange(System.Collections.Generic.IEnumerable<T> collection);
+        void InsertRange(System.Collections.Generic.IEnumerable<T> collection, int index);
+        void Move(int original, int destination);
+        void RemoveRange(int index, int count);
+    }
+    public interface IGroupChangeSet<TObject, TKey, TGroupKey> : DynamicData.IChangeSet, DynamicData.IChangeSet<DynamicData.IGroup<TObject, TKey, TGroupKey>, TGroupKey>, System.Collections.Generic.IEnumerable<DynamicData.Change<DynamicData.IGroup<TObject, TKey, TGroupKey>, TGroupKey>>, System.Collections.IEnumerable
+        where TObject :  notnull
+        where TKey :  notnull
+        where TGroupKey :  notnull { }
+    public interface IGroup<TObject, out TGroup>
+        where TObject :  notnull
+    {
+        TGroup GroupKey { get; }
+        DynamicData.IObservableList<TObject> List { get; }
+    }
+    public interface IGroup<TObject, TKey, out TGroupKey> : DynamicData.IKey<TGroupKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        DynamicData.IObservableCache<TObject, TKey> Cache { get; }
+    }
+    public interface IGrouping<TObject, TKey, out TGroupKey>
+        where TObject :  notnull
+    {
+        int Count { get; }
+        System.Collections.Generic.IEnumerable<TObject> Items { get; }
+        TGroupKey Key { get; }
+        System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>> KeyValues { get; }
+        System.Collections.Generic.IEnumerable<TKey> Keys { get; }
+        DynamicData.Kernel.Optional<TObject> Lookup(TKey key);
+    }
+    public interface IImmutableGroupChangeSet<TObject, TKey, TGroupKey> : DynamicData.IChangeSet, DynamicData.IChangeSet<DynamicData.IGrouping<TObject, TKey, TGroupKey>, TGroupKey>, System.Collections.Generic.IEnumerable<DynamicData.Change<DynamicData.IGrouping<TObject, TKey, TGroupKey>, TGroupKey>>, System.Collections.IEnumerable
+        where TObject :  notnull
+        where TKey :  notnull
+        where TGroupKey :  notnull { }
+    public interface IIntermediateCache<TObject, TKey> : DynamicData.IConnectableCache<TObject, TKey>, DynamicData.IObservableCache<TObject, TKey>, System.IDisposable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        void Edit(System.Action<DynamicData.ICacheUpdater<TObject, TKey>> updateAction);
+    }
+    public interface IKeyValueCollection<TObject, TKey> : System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>>, System.Collections.IEnumerable
+    {
+        System.Collections.Generic.IComparer<System.Collections.Generic.KeyValuePair<TKey, TObject>> Comparer { get; }
+        int Count { get; }
+        System.Collections.Generic.KeyValuePair<TKey, TObject> this[int index] { get; }
+        DynamicData.SortOptimisations Optimisations { get; }
+        DynamicData.SortReason SortReason { get; }
+    }
+    public interface IKeyValue<out TObject, out TKey> : DynamicData.IKey<TKey>
+    {
+        TObject Value { get; }
+    }
+    public interface IKey<out T>
+    {
+        T Key { get; }
+    }
+    public interface IObservableCache<TObject, TKey> : DynamicData.IConnectableCache<TObject, TKey>, System.IDisposable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        int Count { get; }
+        System.Collections.Generic.IEnumerable<TObject> Items { get; }
+        System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>> KeyValues { get; }
+        System.Collections.Generic.IEnumerable<TKey> Keys { get; }
+        DynamicData.Kernel.Optional<TObject> Lookup(TKey key);
+    }
+    public interface IObservableList<T> : System.IDisposable
+        where T :  notnull
+    {
+        int Count { get; }
+        System.IObservable<int> CountChanged { get; }
+        System.Collections.Generic.IEnumerable<T> Items { get; }
+        System.IObservable<DynamicData.IChangeSet<T>> Connect(System.Func<T, bool>? predicate = null);
+        System.IObservable<DynamicData.IChangeSet<T>> Preview(System.Func<T, bool>? predicate = null);
+    }
+    public interface IPageChangeSet<T> : DynamicData.IChangeSet, DynamicData.IChangeSet<T>, System.Collections.Generic.IEnumerable<DynamicData.Change<T>>, System.Collections.IEnumerable
+        where T :  notnull
+    {
+        DynamicData.Operators.IPageResponse Response { get; }
+    }
+    public interface IPageRequest
+    {
+        int Page { get; }
+        int Size { get; }
+    }
+    public interface IPagedChangeSet<TObject, TKey> : DynamicData.IChangeSet, DynamicData.IChangeSet<TObject, TKey>, DynamicData.ISortedChangeSet<TObject, TKey>, System.Collections.Generic.IEnumerable<DynamicData.Change<TObject, TKey>>, System.Collections.IEnumerable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        DynamicData.Operators.IPageResponse Response { get; }
+    }
+    public interface IQuery<TObject, TKey>
+        where TObject :  notnull
+    {
+        int Count { get; }
+        System.Collections.Generic.IEnumerable<TObject> Items { get; }
+        System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>> KeyValues { get; }
+        System.Collections.Generic.IEnumerable<TKey> Keys { get; }
+        DynamicData.Kernel.Optional<TObject> Lookup(TKey key);
+    }
+    public interface ISortedChangeSetAdaptor<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        void Adapt(DynamicData.ISortedChangeSet<TObject, TKey> change);
+    }
+    public interface ISortedChangeSet<TObject, TKey> : DynamicData.IChangeSet, DynamicData.IChangeSet<TObject, TKey>, System.Collections.Generic.IEnumerable<DynamicData.Change<TObject, TKey>>, System.Collections.IEnumerable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        DynamicData.IKeyValueCollection<TObject, TKey> SortedItems { get; }
+    }
+    public interface ISourceCache<TObject, TKey> : DynamicData.IConnectableCache<TObject, TKey>, DynamicData.IObservableCache<TObject, TKey>, System.IDisposable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        System.Func<TObject, TKey> KeySelector { get; }
+        void Edit(System.Action<DynamicData.ISourceUpdater<TObject, TKey>> updateAction);
+    }
+    public interface ISourceList<T> : DynamicData.IObservableList<T>, System.IDisposable
+        where T :  notnull
+    {
+        void Edit(System.Action<DynamicData.IExtendedList<T>> updateAction);
+    }
+    public interface ISourceUpdater<TObject, TKey> : DynamicData.ICacheUpdater<TObject, TKey>, DynamicData.IQuery<TObject, TKey>
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        void AddOrUpdate(System.Collections.Generic.IEnumerable<TObject> items);
+        void AddOrUpdate(TObject item);
+        void AddOrUpdate(System.Collections.Generic.IEnumerable<TObject> items, System.Collections.Generic.IEqualityComparer<TObject> comparer);
+        void AddOrUpdate(TObject item, System.Collections.Generic.IEqualityComparer<TObject> comparer);
+        [System.Obsolete("Use Refresh: Same thing but better semantics")]
+        void Evaluate(System.Collections.Generic.IEnumerable<TObject> items);
+        [System.Obsolete("Use Refresh: Same thing but better semantics")]
+        void Evaluate(TObject item);
+        void Load(System.Collections.Generic.IEnumerable<TObject> items);
+        void Refresh(System.Collections.Generic.IEnumerable<TObject> items);
+        void Refresh(TObject item);
+        void Remove(System.Collections.Generic.IEnumerable<TObject> items);
+        void Remove(TObject item);
+    }
+    public interface IVirtualChangeSet<T> : DynamicData.IChangeSet, DynamicData.IChangeSet<T>, System.Collections.Generic.IEnumerable<DynamicData.Change<T>>, System.Collections.IEnumerable
+        where T :  notnull
+    {
+        DynamicData.IVirtualResponse Response { get; }
+    }
+    public interface IVirtualChangeSet<TObject, TKey> : DynamicData.IChangeSet, DynamicData.IChangeSet<TObject, TKey>, DynamicData.ISortedChangeSet<TObject, TKey>, System.Collections.Generic.IEnumerable<DynamicData.Change<TObject, TKey>>, System.Collections.IEnumerable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        DynamicData.IVirtualResponse Response { get; }
+    }
+    public interface IVirtualRequest
+    {
+        int Size { get; }
+        int StartIndex { get; }
+    }
+    public interface IVirtualResponse
+    {
+        int Size { get; }
+        int StartIndex { get; }
+        int TotalSize { get; }
+    }
+    public sealed class IndexedItem<TObject, TKey> : System.IEquatable<DynamicData.IndexedItem<TObject, TKey>>
+    {
+        public IndexedItem(TObject value, TKey key, int index) { }
+        public int Index { get; }
+        public TKey Key { get; }
+        public TObject Value { get; }
+        public bool Equals(DynamicData.IndexedItem<TObject, TKey>? other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+    }
+    [System.Diagnostics.DebuggerDisplay("IntermediateCache<{typeof(TObject).Name}, {typeof(TKey).Name}> ({Count} Items)")]
+    public sealed class IntermediateCache<TObject, TKey> : DynamicData.IConnectableCache<TObject, TKey>, DynamicData.IIntermediateCache<TObject, TKey>, DynamicData.IObservableCache<TObject, TKey>, System.IDisposable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public IntermediateCache() { }
+        public IntermediateCache(System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source) { }
+        public int Count { get; }
+        public System.IObservable<int> CountChanged { get; }
+        public System.Collections.Generic.IEnumerable<TObject> Items { get; }
+        public System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>> KeyValues { get; }
+        public System.Collections.Generic.IEnumerable<TKey> Keys { get; }
+        public System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Connect(System.Func<TObject, bool>? predicate = null, bool suppressEmptyChangeSets = true) { }
+        public void Dispose() { }
+        public void Edit(System.Action<DynamicData.ICacheUpdater<TObject, TKey>> updateAction) { }
+        public DynamicData.Kernel.Optional<TObject> Lookup(TKey key) { }
+        public System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Preview(System.Func<TObject, bool>? predicate = null) { }
+        public System.IObservable<DynamicData.Change<TObject, TKey>> Watch(TKey key) { }
+    }
+    public readonly struct ItemChange<T> : System.IEquatable<DynamicData.ItemChange<T>>
+        where T :  notnull
+    {
+        public static readonly DynamicData.ItemChange<T> Empty;
+        public ItemChange(DynamicData.ListChangeReason reason, T current, int currentIndex) { }
+        public ItemChange(DynamicData.ListChangeReason reason, T current, DynamicData.Kernel.Optional<T> previous, int currentIndex = -1, int previousIndex = -1) { }
+        public T Current { get; }
+        public int CurrentIndex { get; }
+        public DynamicData.Kernel.Optional<T> Previous { get; }
+        public int PreviousIndex { get; }
+        public DynamicData.ListChangeReason Reason { get; }
+        public bool Equals(DynamicData.ItemChange<T> other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+        public static bool operator !=(DynamicData.ItemChange<T> left, DynamicData.ItemChange<T> right) { }
+        public static bool operator ==(DynamicData.ItemChange<T> left, DynamicData.ItemChange<T> right) { }
+    }
+    public enum ListChangeReason
+    {
+        Add = 0,
+        AddRange = 1,
+        Replace = 2,
+        Remove = 3,
+        RemoveRange = 4,
+        Refresh = 5,
+        Moved = 6,
+        Clear = 7,
+    }
+    public static class ListEx
+    {
+        public static void Add<T>(this System.Collections.Generic.IList<T> source, System.Collections.Generic.IEnumerable<T> items) { }
+        public static void AddOrInsertRange<T>(this System.Collections.Generic.IList<T> source, System.Collections.Generic.IEnumerable<T> items, int index) { }
+        public static void AddRange<T>(this System.Collections.Generic.IList<T> source, System.Collections.Generic.IEnumerable<T> items) { }
+        public static void AddRange<T>(this System.Collections.Generic.IList<T> source, System.Collections.Generic.IEnumerable<T> items, int index) { }
+        public static int BinarySearch<TItem>(this System.Collections.Generic.IList<TItem> list, TItem value) { }
+        public static int BinarySearch<TItem>(this System.Collections.Generic.IList<TItem> list, TItem value, System.Collections.Generic.IComparer<TItem> comparer) { }
+        public static int BinarySearch<TItem, TSearch>(this System.Collections.Generic.IList<TItem> list, TSearch value, System.Func<TSearch, TItem, int> comparer) { }
+        public static void Clone<T>(this System.Collections.Generic.IList<T> source, DynamicData.IChangeSet<T> changes)
+            where T :  notnull { }
+        public static void Clone<T>(this System.Collections.Generic.IList<T> source, DynamicData.IChangeSet<T> changes, System.Collections.Generic.IEqualityComparer<T>? equalityComparer)
+            where T :  notnull { }
+        public static void Clone<T>(this System.Collections.Generic.IList<T> source, System.Collections.Generic.IEnumerable<DynamicData.Change<T>> changes, System.Collections.Generic.IEqualityComparer<T>? equalityComparer)
+            where T :  notnull { }
+        public static int IndexOf<T>(this System.Collections.Generic.IEnumerable<T> source, T item) { }
+        public static int IndexOf<T>(this System.Collections.Generic.IEnumerable<T> source, T item, System.Collections.Generic.IEqualityComparer<T> equalityComparer) { }
+        public static DynamicData.Kernel.Optional<DynamicData.Kernel.ItemWithIndex<T>> IndexOfOptional<T>(this System.Collections.Generic.IEnumerable<T> source, T item, System.Collections.Generic.IEqualityComparer<T>? equalityComparer = null) { }
+        public static void Remove<T>(this System.Collections.Generic.IList<T> source, System.Collections.Generic.IEnumerable<T> items) { }
+        public static void RemoveMany<T>(this System.Collections.Generic.IList<T> source, System.Collections.Generic.IEnumerable<T> itemsToRemove) { }
+        public static void Replace<T>(this System.Collections.Generic.IList<T> source, T original, T replaceWith) { }
+        public static void Replace<T>(this System.Collections.Generic.IList<T> source, T original, T replaceWith, System.Collections.Generic.IEqualityComparer<T> comparer) { }
+        public static void ReplaceOrAdd<T>(this System.Collections.Generic.IList<T> source, T original, T replaceWith) { }
+    }
+    public enum ListFilterPolicy
+    {
+        ClearAndReplace = 0,
+        CalculateDiff = 1,
+    }
+    [System.Serializable]
+    public class MissingKeyException : System.Exception
+    {
+        public MissingKeyException() { }
+        public MissingKeyException(string message) { }
+        protected MissingKeyException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+        public MissingKeyException(string message, System.Exception innerException) { }
+    }
+    public class Node<TObject, TKey> : System.IDisposable, System.IEquatable<DynamicData.Node<TObject, TKey>>
+        where TObject :  class
+        where TKey :  notnull
+    {
+        public Node(TObject item, TKey key) { }
+        public Node(TObject item, TKey key, DynamicData.Kernel.Optional<DynamicData.Node<TObject, TKey>> parent) { }
+        public DynamicData.IObservableCache<DynamicData.Node<TObject, TKey>, TKey> Children { get; }
+        public int Depth { get; }
+        public bool IsRoot { get; }
+        public TObject Item { get; }
+        public TKey Key { get; }
+        public DynamicData.Kernel.Optional<DynamicData.Node<TObject, TKey>> Parent { get; }
+        public void Dispose() { }
+        protected virtual void Dispose(bool isDisposing) { }
+        public bool Equals(DynamicData.Node<TObject, TKey>? other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+        public static bool operator !=(DynamicData.Node<TObject, TKey> left, DynamicData.Node<TObject, TKey> right) { }
+        public static bool operator ==(DynamicData.Node<TObject, TKey>? left, DynamicData.Node<TObject, TKey>? right) { }
+    }
+    public static class ObservableCacheEx
+    {
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Adapt<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, DynamicData.IChangeSetAdaptor<TObject, TKey> adaptor)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Adapt<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source, DynamicData.ISortedChangeSetAdaptor<TObject, TKey> adaptor)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void AddOrUpdate<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.Collections.Generic.IEnumerable<TObject> items)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void AddOrUpdate<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, TObject item)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void AddOrUpdate<TObject, TKey>(this DynamicData.IIntermediateCache<TObject, TKey> source, TObject item, TKey key)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void AddOrUpdate<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.Collections.Generic.IEnumerable<TObject> items, System.Collections.Generic.IEqualityComparer<TObject> equalityComparer)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void AddOrUpdate<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, TObject item, System.Collections.Generic.IEqualityComparer<TObject> equalityComparer)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> And<TObject, TKey>(this DynamicData.IObservableList<DynamicData.IObservableCache<TObject, TKey>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> And<TObject, TKey>(this DynamicData.IObservableList<DynamicData.ISourceCache<TObject, TKey>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> And<TObject, TKey>(this DynamicData.IObservableList<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> And<TObject, TKey>(this System.Collections.Generic.ICollection<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> And<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, params System.IObservable<DynamicData.IChangeSet<TObject, TKey>>[] others)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static DynamicData.IObservableCache<TObject, TKey> AsObservableCache<TObject, TKey>(this DynamicData.IObservableCache<TObject, TKey> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static DynamicData.IObservableCache<TObject, TKey> AsObservableCache<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, bool applyLocking = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> AutoRefresh<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.TimeSpan? changeSetBuffer = default, System.TimeSpan? propertyChangeThrottle = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> AutoRefresh<TObject, TKey, TProperty>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Linq.Expressions.Expression<System.Func<TObject, TProperty>> propertyAccessor, System.TimeSpan? changeSetBuffer = default, System.TimeSpan? propertyChangeThrottle = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> AutoRefreshOnObservable<TObject, TKey, TAny>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<TAny>> reevaluator, System.TimeSpan? changeSetBuffer = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> AutoRefreshOnObservable<TObject, TKey, TAny>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey, System.IObservable<TAny>> reevaluator, System.TimeSpan? changeSetBuffer = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Batch<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.TimeSpan timeSpan, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<bool> pauseIfTrueSelector, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<bool> pauseIfTrueSelector, bool initialPauseState = false, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<bool> pauseIfTrueSelector, System.TimeSpan? timeOut = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<bool> pauseIfTrueSelector, bool initialPauseState = false, System.IObservable<System.Reactive.Unit>? timer = null, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> BatchIf<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<bool> pauseIfTrueSelector, bool initialPauseState = false, System.TimeSpan? timeOut = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> Bind<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source, DynamicData.Binding.IObservableCollection<TObject> destination)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, DynamicData.Binding.IObservableCollection<TObject> destination, DynamicData.Binding.IObservableCollectionAdaptor<TObject, TKey> updater)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, DynamicData.Binding.IObservableCollection<TObject> destination, int refreshThreshold = 25)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.ComponentModel.BindingList<TObject> bindingList, int resetThreshold = 25)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> Bind<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source, DynamicData.Binding.IObservableCollection<TObject> destination, DynamicData.Binding.ISortedObservableCollectionAdaptor<TObject, TKey> updater)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source, System.ComponentModel.BindingList<TObject> bindingList, int resetThreshold = 25)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, out System.Collections.ObjectModel.ReadOnlyObservableCollection<TObject> readOnlyObservableCollection, int resetThreshold = 25, bool useReplaceForUpdates = false, DynamicData.Binding.IObservableCollectionAdaptor<TObject, TKey>? adaptor = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Bind<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source, out System.Collections.ObjectModel.ReadOnlyObservableCollection<TObject> readOnlyObservableCollection, int resetThreshold = 25, bool useReplaceForUpdates = true, DynamicData.Binding.ISortedObservableCollectionAdaptor<TObject, TKey>? adaptor = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> BufferInitial<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.TimeSpan initialBuffer, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Cast<TSource, TKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> converter)
+            where TSource :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TDestinationKey>> ChangeKey<TObject, TSourceKey, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TSourceKey>> source, System.Func<TObject, TDestinationKey> keySelector)
+            where TObject :  notnull
+            where TSourceKey :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TDestinationKey>> ChangeKey<TObject, TSourceKey, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TSourceKey>> source, System.Func<TSourceKey, TObject, TDestinationKey> keySelector)
+            where TObject :  notnull
+            where TSourceKey :  notnull
+            where TDestinationKey :  notnull { }
+        public static void Clear<TObject, TKey>(this DynamicData.Cache.Internal.LockFreeObservableCache<TObject, TKey> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void Clear<TObject, TKey>(this DynamicData.IIntermediateCache<TObject, TKey> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void Clear<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Clone<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Collections.Generic.ICollection<TObject> target)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        [System.Obsolete("This was an experiment that did not work. Use Transform instead")]
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Convert<TObject, TKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TDestination> conversionFactory)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> DeferUntilLoaded<TObject, TKey>(this DynamicData.IObservableCache<TObject, TKey> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> DeferUntilLoaded<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> DisposeMany<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IDistinctChangeSet<TValue>> DistinctValues<TObject, TKey, TValue>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TValue> valueSelector)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TValue :  notnull { }
+        public static void EditDiff<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.Collections.Generic.IEnumerable<TObject> allItems, System.Collections.Generic.IEqualityComparer<TObject> equalityComparer)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void EditDiff<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.Collections.Generic.IEnumerable<TObject> allItems, System.Func<TObject, TObject, bool> areItemsEqual)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> EditDiff<TObject, TKey>(this System.IObservable<DynamicData.Kernel.Optional<TObject>> source, System.Func<TObject, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TObject>? equalityComparer = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> EditDiff<TObject, TKey>(this System.IObservable<System.Collections.Generic.IEnumerable<TObject>> source, System.Func<TObject, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TObject>? equalityComparer = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> EnsureUniqueKeys<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        [System.Obsolete("Use Refresh: Same thing but better semantics")]
+        public static void Evaluate<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        [System.Obsolete("Use Refresh: Same thing but better semantics")]
+        public static void Evaluate<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.Collections.Generic.IEnumerable<TObject> items)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        [System.Obsolete("Use Refresh: Same thing but better semantics")]
+        public static void Evaluate<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, TObject item)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Except<TObject, TKey>(this DynamicData.IObservableList<DynamicData.IObservableCache<TObject, TKey>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Except<TObject, TKey>(this DynamicData.IObservableList<DynamicData.ISourceCache<TObject, TKey>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Except<TObject, TKey>(this DynamicData.IObservableList<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Except<TObject, TKey>(this System.Collections.Generic.ICollection<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Except<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, params System.IObservable<DynamicData.IChangeSet<TObject, TKey>>[] others)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> ExpireAfter<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.TimeSpan?> timeSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>>> ExpireAfter<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.Func<TObject, System.TimeSpan?> timeSelector, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>>> ExpireAfter<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.Func<TObject, System.TimeSpan?> timeSelector, System.TimeSpan? interval = default)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> ExpireAfter<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.TimeSpan?> timeSelector, System.Reactive.Concurrency.IScheduler scheduler)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> ExpireAfter<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.TimeSpan?> timeSelector, System.TimeSpan? pollingInterval)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>>> ExpireAfter<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.Func<TObject, System.TimeSpan?> timeSelector, System.TimeSpan? pollingInterval, System.Reactive.Concurrency.IScheduler? scheduler)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> ExpireAfter<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.TimeSpan?> timeSelector, System.TimeSpan? pollingInterval, System.Reactive.Concurrency.IScheduler scheduler)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Filter<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, bool> filter, bool suppressEmptyChangeSets = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Filter<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<System.Func<TObject, bool>> predicateChanged, bool suppressEmptyChangeSets = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Filter<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<System.Reactive.Unit> reapplyFilter, bool suppressEmptyChangeSets = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Filter<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<System.Func<TObject, bool>> predicateChanged, System.IObservable<System.Reactive.Unit> reapplyFilter, bool suppressEmptyChangeSets = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> FilterOnObservable<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<bool>> filterFactory, System.TimeSpan? buffer = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> FilterOnObservable<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey, System.IObservable<bool>> filterFactory, System.TimeSpan? buffer = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        [System.Obsolete("Use AutoRefresh(), followed by Filter() instead")]
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> FilterOnProperty<TObject, TKey, TProperty>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Linq.Expressions.Expression<System.Func<TObject, TProperty>> propertySelector, System.Func<TObject, bool> predicate, System.TimeSpan? propertyChangedThrottle = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged
+            where TKey :  notnull { }
+        [System.Obsolete("This can cause unhandled exception issues so do not use")]
+        public static System.IObservable<T> FinallySafe<T>(this System.IObservable<T> source, System.Action finallyAction) { }
+        public static System.IObservable<DynamicData.Change<TObject, TKey>> Flatten<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> FlattenBufferResult<TObject, TKey>(this System.IObservable<System.Collections.Generic.IList<DynamicData.IChangeSet<TObject, TKey>>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> ForEachChange<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Action<DynamicData.Change<TObject, TKey>> action)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TLeftKey>> FullJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<DynamicData.Kernel.Optional<TLeft>, DynamicData.Kernel.Optional<TRight>, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TLeftKey>> FullJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<TLeftKey, DynamicData.Kernel.Optional<TLeft>, DynamicData.Kernel.Optional<TRight>, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TLeftKey>> FullJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<DynamicData.Kernel.Optional<TLeft>, DynamicData.IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TLeftKey>> FullJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<TLeftKey, DynamicData.Kernel.Optional<TLeft>, DynamicData.IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TGroupKey> groupSelectorKey)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TGroupKey :  notnull { }
+        public static System.IObservable<DynamicData.IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TGroupKey> groupSelector, System.IObservable<DynamicData.IDistinctChangeSet<TGroupKey>> resultGroupSource)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TGroupKey :  notnull { }
+        public static System.IObservable<DynamicData.IGroupChangeSet<TObject, TKey, TGroupKey>> Group<TObject, TKey, TGroupKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TGroupKey> groupSelectorKey, System.IObservable<System.Reactive.Unit> regrouper)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TGroupKey :  notnull { }
+        public static System.IObservable<DynamicData.IGroupChangeSet<TObject, TKey, TGroupKey>> GroupOnProperty<TObject, TKey, TGroupKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Linq.Expressions.Expression<System.Func<TObject, TGroupKey>> propertySelector, System.TimeSpan? propertyChangedThrottle = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged
+            where TKey :  notnull
+            where TGroupKey :  notnull { }
+        public static System.IObservable<DynamicData.IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> GroupOnPropertyWithImmutableState<TObject, TKey, TGroupKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Linq.Expressions.Expression<System.Func<TObject, TGroupKey>> propertySelector, System.TimeSpan? propertyChangedThrottle = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged
+            where TKey :  notnull
+            where TGroupKey :  notnull { }
+        public static System.IObservable<DynamicData.IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> GroupWithImmutableState<TObject, TKey, TGroupKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TGroupKey> groupSelectorKey, System.IObservable<System.Reactive.Unit>? regrouper = null)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TGroupKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> IgnoreSameReferenceUpdate<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> IgnoreUpdateWhen<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TObject, bool> ignoreFunction)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> IncludeUpdateWhen<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TObject, bool> includeFunction)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "leftKey",
+                "rightKey"})]
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, System.ValueTuple<TLeftKey, TRightKey>>> InnerJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<TLeft, TRight, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        [return: System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "leftKey",
+                "rightKey"})]
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, System.ValueTuple<TLeftKey, TRightKey>>> InnerJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, [System.Runtime.CompilerServices.TupleElementNames(new string[] {
+                "leftKey",
+                "rightKey"})] System.Func<System.ValueTuple<TLeftKey, TRightKey>, TLeft, TRight, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TLeftKey>> InnerJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<TLeft, DynamicData.IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TLeftKey>> InnerJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<TLeftKey, TLeft, DynamicData.IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> InvokeEvaluate<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject : DynamicData.Binding.IEvaluateAware
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TLeftKey>> LeftJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<TLeft, DynamicData.Kernel.Optional<TRight>, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TLeftKey>> LeftJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<TLeftKey, TLeft, DynamicData.Kernel.Optional<TRight>, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TLeftKey>> LeftJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<TLeft, DynamicData.IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TLeftKey>> LeftJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<TLeftKey, TLeft, DynamicData.IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> LimitSizeTo<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, int size)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>>> LimitSizeTo<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, int sizeLimit, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.IObservable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.IObservable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> source, System.Collections.Generic.IComparer<TObject> comparer)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.IObservable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> source, System.Collections.Generic.IEqualityComparer<TObject> equalityComparer)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.Collections.Generic.IEnumerable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> source, System.Reactive.Concurrency.IScheduler? scheduler = null, bool completable = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.IObservable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> source, System.Collections.Generic.IEqualityComparer<TObject> equalityComparer, System.Collections.Generic.IComparer<TObject> comparer)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.Collections.Generic.IEnumerable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> source, System.Collections.Generic.IComparer<TObject> comparer, System.Reactive.Concurrency.IScheduler? scheduler = null, bool completable = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.Collections.Generic.IEnumerable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> source, System.Collections.Generic.IEqualityComparer<TObject> equalityComparer, System.Reactive.Concurrency.IScheduler? scheduler = null, bool completable = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Collections.Generic.IEnumerable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> others, System.Reactive.Concurrency.IScheduler? scheduler = null, bool completable = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<DynamicData.IChangeSet<TObject, TKey>> other, System.Reactive.Concurrency.IScheduler? scheduler = null, bool completable = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.Collections.Generic.IEnumerable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> source, System.Collections.Generic.IEqualityComparer<TObject> equalityComparer, System.Collections.Generic.IComparer<TObject> comparer, System.Reactive.Concurrency.IScheduler? scheduler = null, bool completable = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Collections.Generic.IEnumerable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> others, System.Collections.Generic.IComparer<TObject> comparer, System.Reactive.Concurrency.IScheduler? scheduler = null, bool completable = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Collections.Generic.IEnumerable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> others, System.Collections.Generic.IEqualityComparer<TObject> equalityComparer, System.Reactive.Concurrency.IScheduler? scheduler = null, bool completable = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<DynamicData.IChangeSet<TObject, TKey>> other, System.Collections.Generic.IComparer<TObject> comparer, System.Reactive.Concurrency.IScheduler? scheduler = null, bool completable = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<DynamicData.IChangeSet<TObject, TKey>> other, System.Collections.Generic.IEqualityComparer<TObject> equalityComparer, System.Reactive.Concurrency.IScheduler? scheduler = null, bool completable = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Collections.Generic.IEnumerable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> others, System.Collections.Generic.IEqualityComparer<TObject> equalityComparer, System.Collections.Generic.IComparer<TObject> comparer, System.Reactive.Concurrency.IScheduler? scheduler = null, bool completable = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> MergeChangeSets<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<DynamicData.IChangeSet<TObject, TKey>> other, System.Collections.Generic.IEqualityComparer<TObject> equalityComparer, System.Collections.Generic.IComparer<TObject> comparer, System.Reactive.Concurrency.IScheduler? scheduler = null, bool completable = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<TDestination> MergeMany<TObject, TKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<TDestination>> observableSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<TDestination> MergeMany<TObject, TKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey, System.IObservable<TDestination>> observableSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>>> observableSelector, System.Collections.Generic.IComparer<TDestination> comparer)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey, System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>>> observableSelector, System.Collections.Generic.IComparer<TDestination> comparer)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>>> observableSelector, System.Collections.Generic.IComparer<TObject> sourceComparer, System.Collections.Generic.IComparer<TDestination> childComparer)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>>> observableSelector, System.Collections.Generic.IEqualityComparer<TDestination>? equalityComparer = null, System.Collections.Generic.IComparer<TDestination>? comparer = null)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey, System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>>> observableSelector, System.Collections.Generic.IComparer<TObject> sourceComparer, System.Collections.Generic.IComparer<TDestination> childComparer)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey, System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>>> observableSelector, System.Collections.Generic.IEqualityComparer<TDestination>? equalityComparer = null, System.Collections.Generic.IComparer<TDestination>? comparer = null)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>>> observableSelector, System.Collections.Generic.IComparer<TObject> sourceComparer, bool resortOnSourceRefresh, System.Collections.Generic.IComparer<TDestination> childComparer)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>>> observableSelector, System.Collections.Generic.IComparer<TObject> sourceComparer, System.Collections.Generic.IEqualityComparer<TDestination>? equalityComparer = null, System.Collections.Generic.IComparer<TDestination>? childComparer = null)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey, System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>>> observableSelector, System.Collections.Generic.IComparer<TObject> sourceComparer, bool resortOnSourceRefresh, System.Collections.Generic.IComparer<TDestination> childComparer)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey, System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>>> observableSelector, System.Collections.Generic.IComparer<TObject> sourceComparer, System.Collections.Generic.IEqualityComparer<TDestination>? equalityComparer = null, System.Collections.Generic.IComparer<TDestination>? childComparer = null)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>>> observableSelector, System.Collections.Generic.IComparer<TObject> sourceComparer, bool resortOnSourceRefresh, System.Collections.Generic.IEqualityComparer<TDestination>? equalityComparer = null, System.Collections.Generic.IComparer<TDestination>? childComparer = null)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> MergeManyChangeSets<TObject, TKey, TDestination, TDestinationKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey, System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>>> observableSelector, System.Collections.Generic.IComparer<TObject> sourceComparer, bool resortOnSourceRefresh, System.Collections.Generic.IEqualityComparer<TDestination>? equalityComparer = null, System.Collections.Generic.IComparer<TDestination>? childComparer = null)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull
+            where TDestinationKey :  notnull { }
+        public static System.IObservable<DynamicData.Kernel.ItemWithValue<TObject, TDestination>> MergeManyItems<TObject, TKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<TDestination>> observableSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.Kernel.ItemWithValue<TObject, TDestination>> MergeManyItems<TObject, TKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey, System.IObservable<TDestination>> observableSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.Kernel.ConnectionStatus> MonitorStatus<T>(this System.IObservable<T> source) { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> NotEmpty<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> OnItemAdded<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Action<TObject> addAction)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> OnItemRefreshed<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Action<TObject> refreshAction)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> OnItemRemoved<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Action<TObject> removeAction, bool invokeOnUnsubscribe = true)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> OnItemUpdated<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Action<TObject, TObject> updateAction)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Or<TObject, TKey>(this DynamicData.IObservableList<DynamicData.IObservableCache<TObject, TKey>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Or<TObject, TKey>(this DynamicData.IObservableList<DynamicData.ISourceCache<TObject, TKey>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Or<TObject, TKey>(this DynamicData.IObservableList<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Or<TObject, TKey>(this System.Collections.Generic.ICollection<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Or<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, params System.IObservable<DynamicData.IChangeSet<TObject, TKey>>[] others)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IPagedChangeSet<TObject, TKey>> Page<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source, System.IObservable<DynamicData.IPageRequest> pageRequests)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IDisposable PopulateFrom<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.IObservable<System.Collections.Generic.IEnumerable<TObject>> observable)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IDisposable PopulateFrom<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.IObservable<TObject> observable)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IDisposable PopulateInto<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, DynamicData.Cache.Internal.LockFreeObservableCache<TObject, TKey> destination)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IDisposable PopulateInto<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, DynamicData.IIntermediateCache<TObject, TKey> destination)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IDisposable PopulateInto<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, DynamicData.ISourceCache<TObject, TKey> destination)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IQuery<TObject, TKey>> QueryWhenChanged<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<TDestination> QueryWhenChanged<TObject, TKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<DynamicData.IQuery<TObject, TKey>, TDestination> resultSelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IQuery<TObject, TKey>> QueryWhenChanged<TObject, TKey, TValue>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<TValue>> itemChangedTrigger)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> RefCount<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void Refresh<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void Refresh<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.Collections.Generic.IEnumerable<TObject> items)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void Refresh<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, TObject item)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void Remove<TObject, TKey>(this DynamicData.IIntermediateCache<TObject, TKey> source, System.Collections.Generic.IEnumerable<TKey> keys)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void Remove<TObject, TKey>(this DynamicData.IIntermediateCache<TObject, TKey> source, TKey key)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void Remove<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.Collections.Generic.IEnumerable<TKey> keys)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void Remove<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.Collections.Generic.IEnumerable<TObject> items)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void Remove<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, TKey key)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void Remove<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, TObject item)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject>> RemoveKey<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void RemoveKey<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, TKey key)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static void RemoveKeys<TObject, TKey>(this DynamicData.ISourceCache<TObject, TKey> source, System.Collections.Generic.IEnumerable<TKey> keys)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TRightKey>> RightJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<DynamicData.Kernel.Optional<TLeft>, TRight, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TRightKey>> RightJoin<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<TRightKey, DynamicData.Kernel.Optional<TLeft>, TRight, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TLeftKey>> RightJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<DynamicData.Kernel.Optional<TLeft>, DynamicData.IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TLeftKey>> RightJoinMany<TLeft, TLeftKey, TRight, TRightKey, TDestination>(this System.IObservable<DynamicData.IChangeSet<TLeft, TLeftKey>> left, System.IObservable<DynamicData.IChangeSet<TRight, TRightKey>> right, System.Func<TRight, TLeftKey> rightKeySelector, System.Func<TLeftKey, DynamicData.Kernel.Optional<TLeft>, DynamicData.IGrouping<TRight, TRightKey, TLeftKey>, TDestination> resultSelector)
+            where TLeft :  notnull
+            where TLeftKey :  notnull
+            where TRight :  notnull
+            where TRightKey :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> SkipInitial<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> Sort<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Collections.Generic.IComparer<TObject> comparer, DynamicData.SortOptimisations sortOptimisations = 0, int resetThreshold = 100)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> Sort<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<System.Collections.Generic.IComparer<TObject>> comparerObservable, DynamicData.SortOptimisations sortOptimisations = 0, int resetThreshold = 100)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> Sort<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Collections.Generic.IComparer<TObject> comparer, System.IObservable<System.Reactive.Unit> resorter, DynamicData.SortOptimisations sortOptimisations = 0, int resetThreshold = 100)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> Sort<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.IObservable<System.Collections.Generic.IComparer<TObject>> comparerObservable, System.IObservable<System.Reactive.Unit> resorter, DynamicData.SortOptimisations sortOptimisations = 0, int resetThreshold = 100)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> SortBy<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IComparable> expression, DynamicData.Binding.SortDirection sortOrder = 0, DynamicData.SortOptimisations sortOptimisations = 0, int resetThreshold = 100)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IReadOnlyCollection<T>> StartWithEmpty<T>(this System.IObservable<System.Collections.Generic.IReadOnlyCollection<T>> source) { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> StartWithEmpty<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IPagedChangeSet<TObject, TKey>> StartWithEmpty<TObject, TKey>(this System.IObservable<DynamicData.IPagedChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> StartWithEmpty<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IVirtualChangeSet<TObject, TKey>> StartWithEmpty<TObject, TKey>(this System.IObservable<DynamicData.IVirtualChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IGroupChangeSet<TObject, TKey, TGroupKey>> StartWithEmpty<TObject, TKey, TGroupKey>(this System.IObservable<DynamicData.IGroupChangeSet<TObject, TKey, TGroupKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TGroupKey :  notnull { }
+        public static System.IObservable<DynamicData.IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> StartWithEmpty<TObject, TKey, TGroupKey>(this System.IObservable<DynamicData.IImmutableGroupChangeSet<TObject, TKey, TGroupKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TGroupKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> StartWithItem<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, TObject item)
+            where TObject : DynamicData.IKey<TKey>
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> StartWithItem<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, TObject item, TKey key)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> SubscribeMany<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IDisposable> subscriptionFactory)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> SubscribeMany<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey, System.IDisposable> subscriptionFactory)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> SuppressRefresh<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Switch<TObject, TKey>(this System.IObservable<DynamicData.IObservableCache<TObject, TKey>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Switch<TObject, TKey>(this System.IObservable<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IReadOnlyCollection<TObject>> ToCollection<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> ToObservableChangeSet<TObject, TKey>(this System.IObservable<System.Collections.Generic.IEnumerable<TObject>> source, System.Func<TObject, TKey> keySelector, System.Func<TObject, System.TimeSpan?>? expireAfter = null, int limitSizeTo = -1, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> ToObservableChangeSet<TObject, TKey>(this System.IObservable<TObject> source, System.Func<TObject, TKey> keySelector, System.Func<TObject, System.TimeSpan?>? expireAfter = null, int limitSizeTo = -1, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.Kernel.Optional<TObject>> ToObservableOptional<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, TKey key, System.Collections.Generic.IEqualityComparer<TObject>? equalityComparer = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.Kernel.Optional<TObject>> ToObservableOptional<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, TKey key, bool initialOptionalWhenMissing, System.Collections.Generic.IEqualityComparer<TObject>? equalityComparer = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IReadOnlyCollection<TObject>> ToSortedCollection<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Collections.Generic.IComparer<TObject> comparer)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IReadOnlyCollection<TObject>> ToSortedCollection<TObject, TKey, TSortKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TSortKey> sort, DynamicData.Binding.SortDirection sortOrder = 0)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TSortKey :  notnull { }
+        public static System.IObservable<DynamicData.IVirtualChangeSet<TObject, TKey>> Top<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source, int size)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IVirtualChangeSet<TObject, TKey>> Top<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Collections.Generic.IComparer<TObject> comparer, int size)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, bool transformOnRefresh)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, System.IObservable<System.Reactive.Unit> forceTransform)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, System.IObservable<System.Func<TSource, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, TDestination> transformFactory, bool transformOnRefresh)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, TDestination> transformFactory, System.IObservable<System.Reactive.Unit> forceTransform)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, TDestination> transformFactory, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, DynamicData.Kernel.Optional<TSource>, TKey, TDestination> transformFactory, bool transformOnRefresh)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, DynamicData.Kernel.Optional<TSource>, TKey, TDestination> transformFactory, System.IObservable<System.Reactive.Unit> forceTransform)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, DynamicData.Kernel.Optional<TSource>, TKey, TDestination> transformFactory, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, System.Threading.Tasks.Task<TDestination>> transformFactory, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, System.Threading.Tasks.Task<TDestination>> transformFactory, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformAsync<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, DynamicData.Kernel.Optional<TSource>, TKey, System.Threading.Tasks.Task<TDestination>> transformFactory, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TSourceKey>> source, System.Func<TSource, DynamicData.IObservableCache<TDestination, TDestinationKey>> manySelector, System.Func<TDestination, TDestinationKey> keySelector)
+            where TDestination :  notnull
+            where TDestinationKey :  notnull
+            where TSource :  notnull
+            where TSourceKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TSourceKey>> source, System.Func<TSource, System.Collections.Generic.IEnumerable<TDestination>> manySelector, System.Func<TDestination, TDestinationKey> keySelector)
+            where TDestination :  notnull
+            where TDestinationKey :  notnull
+            where TSource :  notnull
+            where TSourceKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TSourceKey>> source, System.Func<TSource, System.Collections.ObjectModel.ObservableCollection<TDestination>> manySelector, System.Func<TDestination, TDestinationKey> keySelector)
+            where TDestination :  notnull
+            where TDestinationKey :  notnull
+            where TSource :  notnull
+            where TSourceKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TDestinationKey>> TransformMany<TDestination, TDestinationKey, TSource, TSourceKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TSourceKey>> source, System.Func<TSource, System.Collections.ObjectModel.ReadOnlyObservableCollection<TDestination>> manySelector, System.Func<TDestination, TDestinationKey> keySelector)
+            where TDestination :  notnull
+            where TDestinationKey :  notnull
+            where TSource :  notnull
+            where TSourceKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Reactive.Unit> forceTransform)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Func<TSource, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, TDestination> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Reactive.Unit> forceTransform)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, TDestination> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, DynamicData.Kernel.Optional<TSource>, TKey, TDestination> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Reactive.Unit> forceTransform)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, DynamicData.Kernel.Optional<TSource>, TKey, TDestination> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, System.Threading.Tasks.Task<TDestination>> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, System.Threading.Tasks.Task<TDestination>> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafeAsync<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, DynamicData.Kernel.Optional<TSource>, TKey, System.Threading.Tasks.Task<TDestination>> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, System.IObservable<System.Func<TSource, TKey, bool>>? forceTransform = null)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<DynamicData.Node<TObject, TKey>, TKey>> TransformToTree<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey> pivotOn, System.IObservable<System.Func<DynamicData.Node<TObject, TKey>, bool>>? predicateChanged = null)
+            where TObject :  class
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformWithInlineUpdate<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, System.Action<TDestination, TSource> updateAction)
+            where TDestination :  class
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformWithInlineUpdate<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, System.Action<TDestination, TSource> updateAction, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler)
+            where TDestination :  class
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> TreatMovesAsRemoveAdd<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<bool> TrueForAll<TObject, TKey, TValue>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<TValue>> observableSelector, System.Func<TValue, bool> equalityCondition)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TValue :  notnull { }
+        public static System.IObservable<bool> TrueForAll<TObject, TKey, TValue>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<TValue>> observableSelector, System.Func<TObject, TValue, bool> equalityCondition)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TValue :  notnull { }
+        public static System.IObservable<bool> TrueForAny<TObject, TKey, TValue>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<TValue>> observableSelector, System.Func<TValue, bool> equalityCondition)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TValue :  notnull { }
+        public static System.IObservable<bool> TrueForAny<TObject, TKey, TValue>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IObservable<TValue>> observableSelector, System.Func<TObject, TValue, bool> equalityCondition)
+            where TObject :  notnull
+            where TKey :  notnull
+            where TValue :  notnull { }
+        public static System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> UpdateIndex<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source)
+            where TObject : DynamicData.Binding.IIndexAware
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IVirtualChangeSet<TObject, TKey>> Virtualise<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source, System.IObservable<DynamicData.IVirtualRequest> virtualRequests)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.Change<TObject, TKey>> Watch<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, TKey key)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<TObject> WatchValue<TObject, TKey>(this DynamicData.IObservableCache<TObject, TKey> source, TKey key)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<TObject> WatchValue<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, TKey key)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<TObject?> WhenAnyPropertyChanged<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, params string[] propertiesToMonitor)
+            where TObject : System.ComponentModel.INotifyPropertyChanged
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.Binding.PropertyValue<TObject, TValue>> WhenPropertyChanged<TObject, TKey, TValue>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Linq.Expressions.Expression<System.Func<TObject, TValue>> propertyAccessor, bool notifyOnInitialValue = true)
+            where TObject : System.ComponentModel.INotifyPropertyChanged
+            where TKey :  notnull { }
+        public static System.IObservable<TValue?> WhenValueChanged<TObject, TKey, TValue>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Linq.Expressions.Expression<System.Func<TObject, TValue>> propertyAccessor, bool notifyOnInitialValue = true)
+            where TObject : System.ComponentModel.INotifyPropertyChanged
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> WhereReasonsAre<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, params DynamicData.ChangeReason[] reasons)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> WhereReasonsAreNot<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, params DynamicData.ChangeReason[] reasons)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this DynamicData.IObservableList<DynamicData.IObservableCache<TObject, TKey>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this DynamicData.IObservableList<DynamicData.ISourceCache<TObject, TKey>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this DynamicData.IObservableList<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this System.Collections.Generic.ICollection<System.IObservable<DynamicData.IChangeSet<TObject, TKey>>> sources)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Xor<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, params System.IObservable<DynamicData.IChangeSet<TObject, TKey>>[] others)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+    public static class ObservableChangeSet
+    {
+        public static System.IObservable<DynamicData.IChangeSet<T>> Create<T>(System.Func<DynamicData.ISourceList<T>, System.Action> subscribe)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Create<T>(System.Func<DynamicData.ISourceList<T>, System.IDisposable> subscribe)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Create<T>(System.Func<DynamicData.ISourceList<T>, System.Threading.Tasks.Task> subscribe)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Create<T>(System.Func<DynamicData.ISourceList<T>, System.Threading.Tasks.Task<System.Action>> subscribe)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Create<T>(System.Func<DynamicData.ISourceList<T>, System.Threading.Tasks.Task<System.IDisposable>> subscribe)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Create<T>(System.Func<DynamicData.ISourceList<T>, System.Threading.CancellationToken, System.Threading.Tasks.Task> subscribe)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Create<T>(System.Func<DynamicData.ISourceList<T>, System.Threading.CancellationToken, System.Threading.Tasks.Task<System.Action>> subscribe)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Create<T>(System.Func<DynamicData.ISourceList<T>, System.Threading.CancellationToken, System.Threading.Tasks.Task<System.IDisposable>> subscribe)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Create<TObject, TKey>(System.Func<DynamicData.ISourceCache<TObject, TKey>, System.Action> subscribe, System.Func<TObject, TKey> keySelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Create<TObject, TKey>(System.Func<DynamicData.ISourceCache<TObject, TKey>, System.IDisposable> subscribe, System.Func<TObject, TKey> keySelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Create<TObject, TKey>(System.Func<DynamicData.ISourceCache<TObject, TKey>, System.Threading.Tasks.Task> subscribe, System.Func<TObject, TKey> keySelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Create<TObject, TKey>(System.Func<DynamicData.ISourceCache<TObject, TKey>, System.Threading.Tasks.Task<System.Action>> subscribe, System.Func<TObject, TKey> keySelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Create<TObject, TKey>(System.Func<DynamicData.ISourceCache<TObject, TKey>, System.Threading.Tasks.Task<System.IDisposable>> subscribe, System.Func<TObject, TKey> keySelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Create<TObject, TKey>(System.Func<DynamicData.ISourceCache<TObject, TKey>, System.Threading.CancellationToken, System.Threading.Tasks.Task> subscribe, System.Func<TObject, TKey> keySelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Create<TObject, TKey>(System.Func<DynamicData.ISourceCache<TObject, TKey>, System.Threading.CancellationToken, System.Threading.Tasks.Task<System.Action>> subscribe, System.Func<TObject, TKey> keySelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Create<TObject, TKey>(System.Func<DynamicData.ISourceCache<TObject, TKey>, System.Threading.CancellationToken, System.Threading.Tasks.Task<System.IDisposable>> subscribe, System.Func<TObject, TKey> keySelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+    public static class ObservableListEx
+    {
+        public static System.IObservable<DynamicData.IChangeSet<T>> Adapt<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, DynamicData.IChangeSetAdaptor<T> adaptor)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> AddKey<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Func<TObject, TKey> keySelector)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> And<T>(this DynamicData.IObservableList<DynamicData.IObservableList<T>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> And<T>(this DynamicData.IObservableList<DynamicData.ISourceList<T>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> And<T>(this DynamicData.IObservableList<System.IObservable<DynamicData.IChangeSet<T>>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> And<T>(this System.Collections.Generic.ICollection<System.IObservable<DynamicData.IChangeSet<T>>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> And<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, params System.IObservable<DynamicData.IChangeSet<T>>[] others)
+            where T :  notnull { }
+        public static DynamicData.IObservableList<T> AsObservableList<T>(this DynamicData.ISourceList<T> source)
+            where T :  notnull { }
+        public static DynamicData.IObservableList<T> AsObservableList<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject>> AutoRefresh<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.TimeSpan? changeSetBuffer = default, System.TimeSpan? propertyChangeThrottle = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject>> AutoRefresh<TObject, TProperty>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Linq.Expressions.Expression<System.Func<TObject, TProperty>> propertyAccessor, System.TimeSpan? changeSetBuffer = default, System.TimeSpan? propertyChangeThrottle = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject>> AutoRefreshOnObservable<TObject, TAny>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Func<TObject, System.IObservable<TAny>> reevaluator, System.TimeSpan? changeSetBuffer = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Bind<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, DynamicData.Binding.IObservableCollection<T> targetCollection, int resetThreshold = 25)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Bind<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, out System.Collections.ObjectModel.ReadOnlyObservableCollection<T> readOnlyObservableCollection, int resetThreshold = 25)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Bind<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.ComponentModel.BindingList<T> bindingList, int resetThreshold = 25)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> BufferIf<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.IObservable<bool> pauseIfTrueSelector, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> BufferIf<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.IObservable<bool> pauseIfTrueSelector, bool initialPauseState, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> BufferIf<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.IObservable<bool> pauseIfTrueSelector, System.TimeSpan? timeOut, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> BufferIf<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.IObservable<bool> pauseIfTrueSelector, bool initialPauseState, System.TimeSpan? timeOut, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject>> BufferInitial<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.TimeSpan initialBuffer, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> Cast<TDestination>(this System.IObservable<DynamicData.IChangeSet<object>> source)
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> Cast<TSource, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, TDestination> conversionFactory)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<object>> CastToObject<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  class { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Clone<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Collections.Generic.IList<T> target)
+            where T :  notnull { }
+        [System.Obsolete("Prefer Cast as it is does the same thing but is semantically correct")]
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> Convert<TObject, TDestination>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Func<TObject, TDestination> conversionFactory)
+            where TObject :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> DeferUntilLoaded<T>(this DynamicData.IObservableList<T> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> DeferUntilLoaded<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> DisposeMany<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TValue>> DistinctValues<TObject, TValue>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Func<TObject, TValue> valueSelector)
+            where TObject :  notnull
+            where TValue :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Except<T>(this DynamicData.IObservableList<DynamicData.IObservableList<T>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Except<T>(this DynamicData.IObservableList<DynamicData.ISourceList<T>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Except<T>(this DynamicData.IObservableList<System.IObservable<DynamicData.IChangeSet<T>>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Except<T>(this System.Collections.Generic.ICollection<System.IObservable<DynamicData.IChangeSet<T>>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Except<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, params System.IObservable<DynamicData.IChangeSet<T>>[] others)
+            where T :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IEnumerable<T>> ExpireAfter<T>(this DynamicData.ISourceList<T> source, System.Func<T, System.TimeSpan?> timeSelector, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IEnumerable<T>> ExpireAfter<T>(this DynamicData.ISourceList<T> source, System.Func<T, System.TimeSpan?> timeSelector, System.TimeSpan? pollingInterval = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Filter<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, bool> predicate)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Filter<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.IObservable<System.Func<T, bool>> predicate, DynamicData.ListFilterPolicy filterPolicy = 1)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject>> FilterOnObservable<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Func<TObject, System.IObservable<bool>> objectFilterObservable, System.TimeSpan? propertyChangedThrottle = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull { }
+        [System.Obsolete("Use AutoRefresh(), followed by Filter() instead")]
+        public static System.IObservable<DynamicData.IChangeSet<TObject>> FilterOnProperty<TObject, TProperty>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Linq.Expressions.Expression<System.Func<TObject, TProperty>> propertySelector, System.Func<TObject, bool> predicate, System.TimeSpan? propertyChangedThrottle = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> FlattenBufferResult<T>(this System.IObservable<System.Collections.Generic.IList<DynamicData.IChangeSet<T>>> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject>> ForEachChange<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Action<DynamicData.Change<TObject>> action)
+            where TObject :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject>> ForEachItemChange<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Action<DynamicData.ItemChange<TObject>> action)
+            where TObject :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<DynamicData.IGroup<TObject, TGroup>>> GroupOn<TObject, TGroup>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Func<TObject, TGroup> groupSelector, System.IObservable<System.Reactive.Unit>? regrouper = null)
+            where TObject :  notnull
+            where TGroup :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<DynamicData.IGroup<TObject, TGroup>>> GroupOnProperty<TObject, TGroup>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Linq.Expressions.Expression<System.Func<TObject, TGroup>> propertySelector, System.TimeSpan? propertyChangedThrottle = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged
+            where TGroup :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<DynamicData.List.IGrouping<TObject, TGroup>>> GroupOnPropertyWithImmutableState<TObject, TGroup>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Linq.Expressions.Expression<System.Func<TObject, TGroup>> propertySelector, System.TimeSpan? propertyChangedThrottle = default, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject : System.ComponentModel.INotifyPropertyChanged
+            where TGroup :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<DynamicData.List.IGrouping<TObject, TGroupKey>>> GroupWithImmutableState<TObject, TGroupKey>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Func<TObject, TGroupKey> groupSelectorKey, System.IObservable<System.Reactive.Unit>? regrouper = null)
+            where TObject :  notnull
+            where TGroupKey :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IEnumerable<T>> LimitSizeTo<T>(this DynamicData.ISourceList<T> source, int sizeLimit, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<TDestination> MergeMany<T, TDestination>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, System.IObservable<TDestination>> observableSelector)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> NotEmpty<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> OnItemAdded<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Action<T> addAction)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject>> OnItemRefreshed<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Action<TObject> refreshAction)
+            where TObject :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> OnItemRemoved<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Action<T> removeAction, bool invokeOnUnsubscribe = true)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Or<T>(this DynamicData.IObservableList<DynamicData.IObservableList<T>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Or<T>(this DynamicData.IObservableList<DynamicData.ISourceList<T>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Or<T>(this DynamicData.IObservableList<System.IObservable<DynamicData.IChangeSet<T>>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Or<T>(this System.Collections.Generic.ICollection<System.IObservable<DynamicData.IChangeSet<T>>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Or<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, params System.IObservable<DynamicData.IChangeSet<T>>[] others)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IPageChangeSet<T>> Page<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.IObservable<DynamicData.IPageRequest> requests)
+            where T :  notnull { }
+        public static System.IDisposable PopulateInto<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, DynamicData.ISourceList<T> destination)
+            where T :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IReadOnlyCollection<T>> QueryWhenChanged<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<TDestination> QueryWhenChanged<TObject, TDestination>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Func<System.Collections.Generic.IReadOnlyCollection<TObject>, TDestination> resultSelector)
+            where TObject :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> RefCount<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> RemoveIndex<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Reverse<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> SkipInitial<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Sort<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.IObservable<System.Collections.Generic.IComparer<T>> comparerChanged, DynamicData.SortOptions options = 0, System.IObservable<System.Reactive.Unit>? resort = null, int resetThreshold = 50)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Sort<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Collections.Generic.IComparer<T> comparer, DynamicData.SortOptions options = 0, System.IObservable<System.Reactive.Unit>? resort = null, System.IObservable<System.Collections.Generic.IComparer<T>>? comparerChanged = null, int resetThreshold = 50)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> StartWithEmpty<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> SubscribeMany<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.Func<T, System.IDisposable> subscriptionFactory)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> SuppressRefresh<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Switch<T>(this System.IObservable<DynamicData.IObservableList<T>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Switch<T>(this System.IObservable<System.IObservable<DynamicData.IChangeSet<T>>> sources)
+            where T :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IReadOnlyCollection<TObject>> ToCollection<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source)
+            where TObject :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<T>(this System.IObservable<System.Collections.Generic.IEnumerable<T>> source, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<T>(this System.IObservable<T> source, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<T>(this System.IObservable<System.Collections.Generic.IEnumerable<T>> source, System.Func<T, System.TimeSpan?> expireAfter, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<T>(this System.IObservable<System.Collections.Generic.IEnumerable<T>> source, int limitSizeTo, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<T>(this System.IObservable<T> source, System.Func<T, System.TimeSpan?> expireAfter, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<T>(this System.IObservable<T> source, int limitSizeTo, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<T>(this System.IObservable<System.Collections.Generic.IEnumerable<T>> source, System.Func<T, System.TimeSpan?>? expireAfter, int limitSizeTo, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> ToObservableChangeSet<T>(this System.IObservable<T> source, System.Func<T, System.TimeSpan?>? expireAfter, int limitSizeTo, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where T :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IReadOnlyCollection<TObject>> ToSortedCollection<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Collections.Generic.IComparer<TObject> comparer)
+            where TObject :  notnull { }
+        public static System.IObservable<System.Collections.Generic.IReadOnlyCollection<TObject>> ToSortedCollection<TObject, TSortKey>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Func<TObject, TSortKey> sort, DynamicData.Binding.SortDirection sortOrder = 0)
+            where TObject :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Top<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, int numberOfItems)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> Transform<TSource, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, TDestination> transformFactory, bool transformOnRefresh = false)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> Transform<TSource, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, DynamicData.Kernel.Optional<TDestination>, TDestination> transformFactory, bool transformOnRefresh = false)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> Transform<TSource, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, int, TDestination> transformFactory, bool transformOnRefresh = false)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> Transform<TSource, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, DynamicData.Kernel.Optional<TDestination>, int, TDestination> transformFactory, bool transformOnRefresh = false)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, System.Threading.Tasks.Task<TDestination>> transformFactory, bool transformOnRefresh = false)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, DynamicData.Kernel.Optional<TDestination>, System.Threading.Tasks.Task<TDestination>> transformFactory, bool transformOnRefresh = false)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, int, System.Threading.Tasks.Task<TDestination>> transformFactory, bool transformOnRefresh = false)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> TransformAsync<TSource, TDestination>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, DynamicData.Kernel.Optional<TDestination>, int, System.Threading.Tasks.Task<TDestination>> transformFactory, bool transformOnRefresh = false)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, DynamicData.IObservableList<TDestination>> manySelector, System.Collections.Generic.IEqualityComparer<TDestination>? equalityComparer = null)
+            where TDestination :  notnull
+            where TSource :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, System.Collections.Generic.IEnumerable<TDestination>> manySelector, System.Collections.Generic.IEqualityComparer<TDestination>? equalityComparer = null)
+            where TDestination :  notnull
+            where TSource :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, System.Collections.ObjectModel.ObservableCollection<TDestination>> manySelector, System.Collections.Generic.IEqualityComparer<TDestination>? equalityComparer = null)
+            where TDestination :  notnull
+            where TSource :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> TransformMany<TDestination, TSource>(this System.IObservable<DynamicData.IChangeSet<TSource>> source, System.Func<TSource, System.Collections.ObjectModel.ReadOnlyObservableCollection<TDestination>> manySelector, System.Collections.Generic.IEqualityComparer<TDestination>? equalityComparer = null)
+            where TDestination :  notnull
+            where TSource :  notnull { }
+        public static System.IObservable<DynamicData.IVirtualChangeSet<T>> Virtualise<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, System.IObservable<DynamicData.IVirtualRequest> requests)
+            where T :  notnull { }
+        public static System.IObservable<TObject?> WhenAnyPropertyChanged<TObject>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, params string[] propertiesToMonitor)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<DynamicData.Binding.PropertyValue<TObject, TValue>> WhenPropertyChanged<TObject, TValue>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Linq.Expressions.Expression<System.Func<TObject, TValue>> propertyAccessor, bool notifyOnInitialValue = true)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<TValue?> WhenValueChanged<TObject, TValue>(this System.IObservable<DynamicData.IChangeSet<TObject>> source, System.Linq.Expressions.Expression<System.Func<TObject, TValue>> propertyAccessor, bool notifyOnInitialValue = true)
+            where TObject : System.ComponentModel.INotifyPropertyChanged { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> WhereReasonsAre<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, params DynamicData.ListChangeReason[] reasons)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> WhereReasonsAreNot<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, params DynamicData.ListChangeReason[] reasons)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Xor<T>(this DynamicData.IObservableList<DynamicData.IObservableList<T>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Xor<T>(this DynamicData.IObservableList<DynamicData.ISourceList<T>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Xor<T>(this DynamicData.IObservableList<System.IObservable<DynamicData.IChangeSet<T>>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Xor<T>(this System.Collections.Generic.ICollection<System.IObservable<DynamicData.IChangeSet<T>>> sources)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<T>> Xor<T>(this System.IObservable<DynamicData.IChangeSet<T>> source, params System.IObservable<DynamicData.IChangeSet<T>>[] others)
+            where T :  notnull { }
+    }
+    public static class ObsoleteEx { }
+    public sealed class PageRequest : DynamicData.IPageRequest, System.IEquatable<DynamicData.IPageRequest>
+    {
+        public static readonly DynamicData.IPageRequest Default;
+        public static readonly DynamicData.IPageRequest Empty;
+        public PageRequest() { }
+        public PageRequest(int page, int size) { }
+        public System.Collections.Generic.IEqualityComparer<DynamicData.IPageRequest?> DefaultComparer { get; }
+        public int Page { get; }
+        public int Size { get; }
+        public bool Equals(DynamicData.IPageRequest? other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+    }
+    public sealed class RangeChange<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable
+    {
+        public RangeChange(System.Collections.Generic.IEnumerable<T> items, int index = -1) { }
+        public int Count { get; }
+        public int Index { get; }
+        public static DynamicData.RangeChange<T> Empty { get; }
+        public void Add(T item) { }
+        public System.Collections.Generic.IEnumerator<T> GetEnumerator() { }
+        public void Insert(int index, T item) { }
+        public void SetStartingIndex(int index) { }
+        public override string ToString() { }
+    }
+    [System.Serializable]
+    public class SortException : System.Exception
+    {
+        public SortException() { }
+        public SortException(string message) { }
+        protected SortException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+        public SortException(string message, System.Exception innerException) { }
+    }
+    [System.Flags]
+    public enum SortOptimisations
+    {
+        None = 0,
+        ComparesImmutableValuesOnly = 1,
+        IgnoreEvaluates = 2,
+        [System.Obsolete("This is no longer being used. Use one of the other options instead.")]
+        InsertAtEndThenSort = 3,
+    }
+    public enum SortOptions
+    {
+        None = 0,
+        UseBinarySearch = 1,
+    }
+    public enum SortReason
+    {
+        InitialLoad = 0,
+        ComparerChanged = 1,
+        DataChanged = 2,
+        Reorder = 3,
+        Reset = 4,
+    }
+    public static class SourceCacheEx
+    {
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Cast<TSource, TKey, TDestination>(this DynamicData.IObservableCache<TSource, TKey> source, System.Func<TSource, TDestination> converter)
+            where TSource :  notnull
+            where TKey :  notnull
+            where TDestination :  notnull { }
+    }
+    [System.Diagnostics.DebuggerDisplay("SourceCache<{typeof(TObject).Name}, {typeof(TKey).Name}> ({Count} Items)")]
+    public sealed class SourceCache<TObject, TKey> : DynamicData.IConnectableCache<TObject, TKey>, DynamicData.IObservableCache<TObject, TKey>, DynamicData.ISourceCache<TObject, TKey>, System.IDisposable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public SourceCache(System.Func<TObject, TKey> keySelector) { }
+        public int Count { get; }
+        public System.IObservable<int> CountChanged { get; }
+        public System.Collections.Generic.IEnumerable<TObject> Items { get; }
+        public System.Func<TObject, TKey> KeySelector { get; }
+        public System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TObject>> KeyValues { get; }
+        public System.Collections.Generic.IEnumerable<TKey> Keys { get; }
+        public System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Connect(System.Func<TObject, bool>? predicate = null, bool suppressEmptyChangeSets = true) { }
+        public void Dispose() { }
+        public void Edit(System.Action<DynamicData.ISourceUpdater<TObject, TKey>> updateAction) { }
+        public DynamicData.Kernel.Optional<TObject> Lookup(TKey key) { }
+        public System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Preview(System.Func<TObject, bool>? predicate = null) { }
+        public System.IObservable<DynamicData.Change<TObject, TKey>> Watch(TKey key) { }
+    }
+    public static class SourceListEditConvenienceEx
+    {
+        public static void Add<T>(this DynamicData.ISourceList<T> source, T item)
+            where T :  notnull { }
+        public static void AddRange<T>(this DynamicData.ISourceList<T> source, System.Collections.Generic.IEnumerable<T> items)
+            where T :  notnull { }
+        public static void Clear<T>(this DynamicData.ISourceList<T> source)
+            where T :  notnull { }
+        public static void EditDiff<T>(this DynamicData.ISourceList<T> source, System.Collections.Generic.IEnumerable<T> allItems, System.Collections.Generic.IEqualityComparer<T>? equalityComparer = null)
+            where T :  notnull { }
+        public static void Insert<T>(this DynamicData.ISourceList<T> source, int index, T item)
+            where T :  notnull { }
+        public static void InsertRange<T>(this DynamicData.ISourceList<T> source, System.Collections.Generic.IEnumerable<T> items, int index)
+            where T :  notnull { }
+        public static void Move<T>(this DynamicData.ISourceList<T> source, int original, int destination)
+            where T :  notnull { }
+        public static bool Remove<T>(this DynamicData.ISourceList<T> source, T item)
+            where T :  notnull { }
+        public static void RemoveAt<T>(this DynamicData.ISourceList<T> source, int index)
+            where T :  notnull { }
+        public static void RemoveMany<T>(this DynamicData.ISourceList<T> source, System.Collections.Generic.IEnumerable<T> itemsToRemove)
+            where T :  notnull { }
+        public static void RemoveRange<T>(this DynamicData.ISourceList<T> source, int index, int count)
+            where T :  notnull { }
+        public static void Replace<T>(this DynamicData.ISourceList<T> source, T original, T destination)
+            where T :  notnull { }
+        public static void ReplaceAt<T>(this DynamicData.ISourceList<T> source, int index, T item)
+            where T :  notnull { }
+    }
+    public static class SourceListEx
+    {
+        public static System.IObservable<DynamicData.IChangeSet<TDestination>> Cast<TSource, TDestination>(this DynamicData.ISourceList<TSource> source, System.Func<TSource, TDestination> conversionFactory)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+    }
+    [System.Diagnostics.DebuggerDisplay("SourceList<{typeof(T).Name}> ({Count} Items)")]
+    public sealed class SourceList<T> : DynamicData.IObservableList<T>, DynamicData.ISourceList<T>, System.IDisposable
+        where T :  notnull
+    {
+        public SourceList(System.IObservable<DynamicData.IChangeSet<T>>? source = null) { }
+        public int Count { get; }
+        public System.IObservable<int> CountChanged { get; }
+        public System.Collections.Generic.IEnumerable<T> Items { get; }
+        public System.IObservable<DynamicData.IChangeSet<T>> Connect(System.Func<T, bool>? predicate = null) { }
+        public void Dispose() { }
+        public void Edit(System.Action<DynamicData.IExtendedList<T>> updateAction) { }
+        public System.IObservable<DynamicData.IChangeSet<T>> Preview(System.Func<T, bool>? predicate = null) { }
+    }
+    [System.Serializable]
+    public class UnspecifiedIndexException : System.Exception
+    {
+        public UnspecifiedIndexException() { }
+        public UnspecifiedIndexException(string message) { }
+        protected UnspecifiedIndexException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+        public UnspecifiedIndexException(string message, System.Exception innerException) { }
+    }
+    public class VirtualRequest : DynamicData.IVirtualRequest, System.IEquatable<DynamicData.IVirtualRequest>
+    {
+        public static readonly DynamicData.VirtualRequest Default;
+        public VirtualRequest() { }
+        public VirtualRequest(int startIndex, int size) { }
+        public int Size { get; }
+        public int StartIndex { get; }
+        public static System.Collections.Generic.IEqualityComparer<DynamicData.IVirtualRequest?> StartIndexSizeComparer { get; }
+        public bool Equals(DynamicData.IVirtualRequest? other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+    }
+}
+namespace DynamicData.Diagnostics
+{
+    public class ChangeStatistics : System.IEquatable<DynamicData.Diagnostics.ChangeStatistics>
+    {
+        public ChangeStatistics() { }
+        public ChangeStatistics(int index, int adds, int updates, int removes, int refreshes, int moves, int count) { }
+        public int Adds { get; }
+        public int Count { get; }
+        public int Index { get; }
+        public System.DateTime LastUpdated { get; }
+        public int Moves { get; }
+        public int Refreshes { get; }
+        public int Removes { get; }
+        public int Updates { get; }
+        public bool Equals(DynamicData.Diagnostics.ChangeStatistics? other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+        public static bool operator !=(DynamicData.Diagnostics.ChangeStatistics left, DynamicData.Diagnostics.ChangeStatistics right) { }
+        public static bool operator ==(DynamicData.Diagnostics.ChangeStatistics left, DynamicData.Diagnostics.ChangeStatistics right) { }
+    }
+    public class ChangeSummary
+    {
+        public static readonly DynamicData.Diagnostics.ChangeSummary Empty;
+        public ChangeSummary(int index, DynamicData.Diagnostics.ChangeStatistics latest, DynamicData.Diagnostics.ChangeStatistics overall) { }
+        public DynamicData.Diagnostics.ChangeStatistics Latest { get; }
+        public DynamicData.Diagnostics.ChangeStatistics Overall { get; }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+    }
+    public static class DiagnosticOperators
+    {
+        public static System.IObservable<DynamicData.Diagnostics.ChangeSummary> CollectUpdateStats<TSource>(this System.IObservable<DynamicData.IChangeSet<TSource>> source)
+            where TSource :  notnull { }
+        public static System.IObservable<DynamicData.Diagnostics.ChangeSummary> CollectUpdateStats<TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source)
+            where TSource :  notnull
+            where TKey :  notnull { }
+    }
+}
+namespace DynamicData.Experimental
+{
+    public static class ExperimentalEx
+    {
+        public static DynamicData.Experimental.IWatcher<TObject, TKey> AsWatcher<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Reactive.Concurrency.IScheduler? scheduler = null)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+    public interface IWatcher<TObject, TKey> : System.IDisposable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        System.IObservable<DynamicData.Change<TObject, TKey>> Watch(TKey key);
+    }
+}
+namespace DynamicData.Kernel
+{
+    public enum ConnectionStatus
+    {
+        Pending = 0,
+        Loaded = 1,
+        Errored = 2,
+        Completed = 3,
+    }
+    public static class EnumerableEx
+    {
+        public static T[] AsArray<T>(this System.Collections.Generic.IEnumerable<T> source) { }
+        public static System.Collections.Generic.List<T> AsList<T>(this System.Collections.Generic.IEnumerable<T> source) { }
+        public static System.Collections.Generic.IEnumerable<T> Duplicates<T, TValue>(this System.Collections.Generic.IEnumerable<T> source, System.Func<T, TValue> valueSelector) { }
+        public static System.Collections.Generic.IEnumerable<DynamicData.Kernel.ItemWithIndex<T>> IndexOfMany<T>(this System.Collections.Generic.IEnumerable<T> source, System.Collections.Generic.IEnumerable<T> itemsToFind) { }
+        public static System.Collections.Generic.IEnumerable<TResult> IndexOfMany<TObject, TResult>(this System.Collections.Generic.IEnumerable<TObject> source, System.Collections.Generic.IEnumerable<TObject> itemsToFind, System.Func<TObject, int, TResult> resultSelector) { }
+    }
+    public sealed class Error<TObject, TKey> : DynamicData.IKeyValue<TObject, TKey>, DynamicData.IKey<TKey>, System.IEquatable<DynamicData.Kernel.Error<TObject, TKey>>
+        where TKey :  notnull
+    {
+        public Error(System.Exception? exception, TObject value, TKey key) { }
+        public System.Exception? Exception { get; }
+        public TKey Key { get; }
+        public TObject Value { get; }
+        public bool Equals(DynamicData.Kernel.Error<TObject, TKey>? other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+        public static bool operator !=(DynamicData.Kernel.Error<TObject, TKey> left, DynamicData.Kernel.Error<TObject, TKey> right) { }
+        public static bool operator ==(DynamicData.Kernel.Error<TObject, TKey> left, DynamicData.Kernel.Error<TObject, TKey> right) { }
+    }
+    public static class InternalEx
+    {
+        public static System.IObservable<TSource> RetryWithBackOff<TSource, TException>(this System.IObservable<TSource> source, System.Func<TException, int, System.TimeSpan?> backOffStrategy)
+            where TException : System.Exception { }
+        public static System.IDisposable ScheduleRecurringAction(this System.Reactive.Concurrency.IScheduler scheduler, System.Func<System.TimeSpan> interval, System.Action action) { }
+        public static System.IDisposable ScheduleRecurringAction(this System.Reactive.Concurrency.IScheduler scheduler, System.TimeSpan interval, System.Action action) { }
+    }
+    public readonly struct ItemWithIndex<T> : System.IEquatable<DynamicData.Kernel.ItemWithIndex<T>>
+    {
+        public ItemWithIndex(T item, int index) { }
+        public int Index { get; }
+        public T Item { get; }
+        public bool Equals(DynamicData.Kernel.ItemWithIndex<T> other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+        public static bool operator !=(DynamicData.Kernel.ItemWithIndex<T> left, DynamicData.Kernel.ItemWithIndex<T> right) { }
+        public static bool operator ==(DynamicData.Kernel.ItemWithIndex<T> left, DynamicData.Kernel.ItemWithIndex<T> right) { }
+    }
+    public readonly struct ItemWithValue<TObject, TValue> : System.IEquatable<DynamicData.Kernel.ItemWithValue<TObject, TValue>>
+    {
+        public ItemWithValue(TObject item, TValue value) { }
+        public TObject Item { get; }
+        public TValue Value { get; }
+        public bool Equals(DynamicData.Kernel.ItemWithValue<TObject, TValue> other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string ToString() { }
+        public static bool operator !=(DynamicData.Kernel.ItemWithValue<TObject, TValue> left, DynamicData.Kernel.ItemWithValue<TObject, TValue> right) { }
+        public static bool operator ==(DynamicData.Kernel.ItemWithValue<TObject, TValue> left, DynamicData.Kernel.ItemWithValue<TObject, TValue> right) { }
+    }
+    public sealed class OptionElse
+    {
+        public void Else(System.Action action) { }
+    }
+    public static class OptionExtensions
+    {
+        public static DynamicData.Kernel.Optional<TDestination> Convert<TSource, TDestination>(this DynamicData.Kernel.Optional<TSource> source, System.Func<TSource, DynamicData.Kernel.Optional<TDestination>> converter)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static DynamicData.Kernel.Optional<TDestination> Convert<TSource, TDestination>(this DynamicData.Kernel.Optional<TSource> source, System.Func<TSource, TDestination> converter)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static TDestination? ConvertOr<TSource, TDestination>(this DynamicData.Kernel.Optional<TSource> source, System.Func<TSource?, TDestination?> converter, System.Func<TDestination?> fallbackConverter)
+            where TSource :  notnull { }
+        public static DynamicData.Kernel.Optional<T> FirstOrOptional<T>(this System.Collections.Generic.IEnumerable<T> source, System.Func<T, bool> selector)
+            where T :  notnull { }
+        public static DynamicData.Kernel.OptionElse IfHasValue<T>(this DynamicData.Kernel.Optional<T> source, System.Action<T> action)
+            where T :  notnull { }
+        public static DynamicData.Kernel.OptionElse IfHasValue<T>(this DynamicData.Kernel.Optional<T>? source, System.Action<T> action)
+            where T :  notnull { }
+        public static DynamicData.Kernel.Optional<TValue> Lookup<TValue, TKey>(this System.Collections.Generic.IDictionary<TKey, TValue> source, TKey key)
+            where TValue :  notnull { }
+        public static DynamicData.Kernel.Optional<T> OrElse<T>(this DynamicData.Kernel.Optional<T> source, System.Func<DynamicData.Kernel.Optional<T>> fallbackOperation)
+            where T :  notnull { }
+        public static bool RemoveIfContained<TValue, TKey>(this System.Collections.Generic.IDictionary<TKey, TValue> source, TKey key) { }
+        public static System.Collections.Generic.IEnumerable<T> SelectValues<T>(this System.Collections.Generic.IEnumerable<DynamicData.Kernel.Optional<T>> source)
+            where T :  notnull { }
+        public static T ValueOr<T>(this DynamicData.Kernel.Optional<T> source, System.Func<T> valueSelector)
+            where T :  notnull { }
+        public static T ValueOr<T>(this T? source, T defaultValue)
+            where T :  struct { }
+        public static T? ValueOrDefault<T>(this DynamicData.Kernel.Optional<T> source)
+            where T :  notnull { }
+        public static T ValueOrThrow<T>(this DynamicData.Kernel.Optional<T> source, System.Func<System.Exception> exceptionGenerator)
+            where T :  notnull { }
+    }
+    public static class OptionObservableExtensions
+    {
+        public static System.IObservable<DynamicData.Kernel.Optional<TDestination>> Convert<TSource, TDestination>(this System.IObservable<DynamicData.Kernel.Optional<TSource>> source, System.Func<TSource, DynamicData.Kernel.Optional<TDestination>> converter)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<DynamicData.Kernel.Optional<TDestination>> Convert<TSource, TDestination>(this System.IObservable<DynamicData.Kernel.Optional<TSource>> source, System.Func<TSource, TDestination> converter)
+            where TSource :  notnull
+            where TDestination :  notnull { }
+        public static System.IObservable<TDestination?> ConvertOr<TSource, TDestination>(this System.IObservable<DynamicData.Kernel.Optional<TSource>> source, System.Func<TSource, TDestination?> converter, System.Func<TDestination?> fallbackConverter)
+            where TSource :  notnull { }
+        public static System.IObservable<DynamicData.Kernel.Optional<T>> OnHasNoValue<T>(this System.IObservable<DynamicData.Kernel.Optional<T>> source, System.Action action, System.Action<T>? elseAction = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.Kernel.Optional<T>> OnHasValue<T>(this System.IObservable<DynamicData.Kernel.Optional<T>> source, System.Action<T> action, System.Action? elseAction = null)
+            where T :  notnull { }
+        public static System.IObservable<DynamicData.Kernel.Optional<T>> OrElse<T>(this System.IObservable<DynamicData.Kernel.Optional<T>> source, System.Func<DynamicData.Kernel.Optional<T>> fallbackOperation)
+            where T :  notnull { }
+        public static System.IObservable<T> SelectValues<T>(this System.IObservable<DynamicData.Kernel.Optional<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<T> ValueOr<T>(this System.IObservable<DynamicData.Kernel.Optional<T>> source, System.Func<T> valueSelector)
+            where T :  notnull { }
+        public static System.IObservable<T?> ValueOrDefault<T>(this System.IObservable<DynamicData.Kernel.Optional<T>> source)
+            where T :  notnull { }
+        public static System.IObservable<T> ValueOrThrow<T>(this System.IObservable<DynamicData.Kernel.Optional<T>> source, System.Func<System.Exception> exceptionGenerator)
+            where T :  notnull { }
+    }
+    public static class Optional
+    {
+        public static DynamicData.Kernel.Optional<T> None<T>()
+            where T :  notnull { }
+        public static DynamicData.Kernel.Optional<T> Some<T>(T? value)
+            where T :  notnull { }
+    }
+    public readonly struct Optional<T> : System.IEquatable<DynamicData.Kernel.Optional<T>>
+        where T :  notnull
+    {
+        public bool HasValue { get; }
+        public T Value { get; }
+        public static DynamicData.Kernel.Optional<T> None { get; }
+        public bool Equals(DynamicData.Kernel.Optional<T> other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
+        public override string? ToString() { }
+        public static DynamicData.Kernel.Optional<T> Create(T? value) { }
+        public static T? FromOptional(DynamicData.Kernel.Optional<T> value) { }
+        public static DynamicData.Kernel.Optional<T> ToOptional(T? value) { }
+        public static T? op_Explicit(DynamicData.Kernel.Optional<T> value) { }
+        public static DynamicData.Kernel.Optional<T> op_Implicit(T? value) { }
+        public static bool operator !=(DynamicData.Kernel.Optional<T> left, DynamicData.Kernel.Optional<T> right) { }
+        public static bool operator ==(DynamicData.Kernel.Optional<T> left, DynamicData.Kernel.Optional<T> right) { }
+    }
+}
+namespace DynamicData.List
+{
+    public interface IGrouping<out TObject, out TGroupKey>
+    {
+        int Count { get; }
+        System.Collections.Generic.IEnumerable<TObject> Items { get; }
+        TGroupKey Key { get; }
+    }
+}
+namespace DynamicData.Operators
+{
+    public interface IPageResponse
+    {
+        int Page { get; }
+        int PageSize { get; }
+        int Pages { get; }
+        int TotalSize { get; }
+    }
+}
+namespace DynamicData.PLinq
+{
+    public static class ParallelOperators
+    {
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> Filter<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, bool> filter, DynamicData.PLinq.ParallelisationOptions parallelisationOptions)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> SubscribeMany<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, System.IDisposable> subscriptionFactory, DynamicData.PLinq.ParallelisationOptions parallelisationOptions)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TObject, TKey>> SubscribeMany<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source, System.Func<TObject, TKey, System.IDisposable> subscriptionFactory, DynamicData.PLinq.ParallelisationOptions parallelisationOptions)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, DynamicData.PLinq.ParallelisationOptions parallelisationOptions)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> Transform<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, TDestination> transformFactory, DynamicData.PLinq.ParallelisationOptions parallelisationOptions)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TDestination> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, DynamicData.PLinq.ParallelisationOptions parallelisationOptions)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+        public static System.IObservable<DynamicData.IChangeSet<TDestination, TKey>> TransformSafe<TDestination, TSource, TKey>(this System.IObservable<DynamicData.IChangeSet<TSource, TKey>> source, System.Func<TSource, TKey, TDestination> transformFactory, System.Action<DynamicData.Kernel.Error<TSource, TKey>> errorHandler, DynamicData.PLinq.ParallelisationOptions parallelisationOptions)
+            where TDestination :  notnull
+            where TSource :  notnull
+            where TKey :  notnull { }
+    }
+    public enum ParallelType
+    {
+        None = 0,
+        Parallelise = 1,
+        Ordered = 2,
+    }
+    public class ParallelisationOptions
+    {
+        public static readonly DynamicData.PLinq.ParallelisationOptions Default;
+        public static readonly DynamicData.PLinq.ParallelisationOptions None;
+        public ParallelisationOptions(DynamicData.PLinq.ParallelType type = 0, int threshold = 0, int maxDegreeOfParallelisation = 0) { }
+        public int MaxDegreeOfParallelisation { get; }
+        public int Threshold { get; }
+        public DynamicData.PLinq.ParallelType Type { get; }
+    }
+}
+namespace DynamicData.Tests
+{
+    public class ChangeSetAggregator<TObject> : System.IDisposable
+        where TObject :  notnull
+    {
+        public ChangeSetAggregator(System.IObservable<DynamicData.IChangeSet<TObject>> source) { }
+        public DynamicData.IObservableList<TObject> Data { get; }
+        public System.Exception? Exception { get; set; }
+        public System.Collections.Generic.IList<DynamicData.IChangeSet<TObject>> Messages { get; }
+        public void Dispose() { }
+        protected virtual void Dispose(bool isDisposing) { }
+    }
+    public class ChangeSetAggregator<TObject, TKey> : System.IDisposable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public ChangeSetAggregator(System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source) { }
+        public bool Completed { get; }
+        public DynamicData.IObservableCache<TObject, TKey> Data { get; }
+        public System.Exception? Error { get; }
+        public System.Collections.Generic.IList<DynamicData.IChangeSet<TObject, TKey>> Messages { get; }
+        public DynamicData.Diagnostics.ChangeSummary Summary { get; }
+        public void Dispose() { }
+        protected virtual void Dispose(bool isDisposing) { }
+    }
+    public class DistinctChangeSetAggregator<TValue> : System.IDisposable
+        where TValue :  notnull
+    {
+        public DistinctChangeSetAggregator(System.IObservable<DynamicData.IDistinctChangeSet<TValue>> source) { }
+        public DynamicData.IObservableCache<TValue, TValue> Data { get; }
+        public System.Exception? Error { get; }
+        public System.Collections.Generic.IList<DynamicData.IChangeSet<TValue, TValue>> Messages { get; }
+        public DynamicData.Diagnostics.ChangeSummary Summary { get; }
+        public void Dispose() { }
+        protected virtual void Dispose(bool isDisposing) { }
+    }
+    public static class ListTextEx
+    {
+        public static DynamicData.Tests.ChangeSetAggregator<T> AsAggregator<T>(this System.IObservable<DynamicData.IChangeSet<T>> source)
+            where T :  notnull { }
+    }
+    public class PagedChangeSetAggregator<TObject, TKey> : System.IDisposable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public PagedChangeSetAggregator(System.IObservable<DynamicData.IPagedChangeSet<TObject, TKey>> source) { }
+        public DynamicData.IObservableCache<TObject, TKey> Data { get; }
+        public System.Exception? Error { get; }
+        public System.Collections.Generic.IList<DynamicData.IPagedChangeSet<TObject, TKey>> Messages { get; }
+        public DynamicData.Diagnostics.ChangeSummary Summary { get; }
+        public void Dispose() { }
+        protected virtual void Dispose(bool isDisposing) { }
+    }
+    public class SortedChangeSetAggregator<TObject, TKey> : System.IDisposable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public SortedChangeSetAggregator(System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source) { }
+        public DynamicData.IObservableCache<TObject, TKey> Data { get; }
+        public System.Exception? Error { get; }
+        public System.Collections.Generic.IList<DynamicData.ISortedChangeSet<TObject, TKey>> Messages { get; }
+        public DynamicData.Diagnostics.ChangeSummary Summary { get; }
+        public void Dispose() { }
+        protected virtual void Dispose(bool isDisposing) { }
+    }
+    public static class TestEx
+    {
+        public static DynamicData.Tests.DistinctChangeSetAggregator<TValue> AsAggregator<TValue>(this System.IObservable<DynamicData.IDistinctChangeSet<TValue>> source)
+            where TValue :  notnull { }
+        public static DynamicData.Tests.ChangeSetAggregator<TObject, TKey> AsAggregator<TObject, TKey>(this System.IObservable<DynamicData.IChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static DynamicData.Tests.PagedChangeSetAggregator<TObject, TKey> AsAggregator<TObject, TKey>(this System.IObservable<DynamicData.IPagedChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static DynamicData.Tests.SortedChangeSetAggregator<TObject, TKey> AsAggregator<TObject, TKey>(this System.IObservable<DynamicData.ISortedChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+        public static DynamicData.Tests.VirtualChangeSetAggregator<TObject, TKey> AsAggregator<TObject, TKey>(this System.IObservable<DynamicData.IVirtualChangeSet<TObject, TKey>> source)
+            where TObject :  notnull
+            where TKey :  notnull { }
+    }
+    public class VirtualChangeSetAggregator<TObject, TKey> : System.IDisposable
+        where TObject :  notnull
+        where TKey :  notnull
+    {
+        public VirtualChangeSetAggregator(System.IObservable<DynamicData.IVirtualChangeSet<TObject, TKey>> source) { }
+        public DynamicData.IObservableCache<TObject, TKey> Data { get; }
+        public System.Exception? Error { get; }
+        public System.Collections.Generic.IList<DynamicData.IVirtualChangeSet<TObject, TKey>> Messages { get; }
+        public DynamicData.Diagnostics.ChangeSummary Summary { get; }
+        public void Dispose() { }
+        protected virtual void Dispose(bool isDisposing) { }
+    }
+}
\ No newline at end of file
diff --git a/src/DynamicData.Tests/API/ApiApprovalTests.cs b/src/DynamicData.Tests/API/ApiApprovalTests.cs
new file mode 100644
index 000000000..6a6906cd4
--- /dev/null
+++ b/src/DynamicData.Tests/API/ApiApprovalTests.cs
@@ -0,0 +1,20 @@
+using System.Diagnostics.CodeAnalysis;
+using VerifyXunit;
+using Xunit;
+
+namespace DynamicData.APITests
+{
+    /// <summary>
+    /// Tests for handling API approval.
+    /// </summary>
+    [ExcludeFromCodeCoverage]
+    [UsesVerify]
+    public class ApiApprovalTests : ApiApprovalBase
+    {
+        /// <summary>
+        /// Tests to make sure the DynamicData project is approved.
+        /// </summary>
+        [Fact]
+        public void DynamicDataTests() => CheckApproval(typeof(VirtualRequest).Assembly);
+    }
+}
diff --git a/src/DynamicData.Tests/DynamicData.Tests.csproj b/src/DynamicData.Tests/DynamicData.Tests.csproj
index ce14a216b..927b377e7 100644
--- a/src/DynamicData.Tests/DynamicData.Tests.csproj
+++ b/src/DynamicData.Tests/DynamicData.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="MSBuild.Sdk.Extras">
+<Project Sdk="MSBuild.Sdk.Extras">
   <PropertyGroup>
     <TargetFrameworks>net6.0</TargetFrameworks>
     <NoWarn>$(NoWarn);CS0618;CA1801;CA1063;CS8767;CS8602; CS8618</NoWarn>
@@ -11,12 +11,14 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
     <PackageReference Include="xunit" Version="2.6.1" />
     <PackageReference Include="xunit.runner.console" Version="2.6.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
+    <PackageReference Include="Verify.Xunit" Version="22.4.1" />
     <PackageReference Include="FluentAssertions" Version="6.12.0" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="6.0.0" />
+    <PackageReference Include="PublicApiGenerator" Version="11.0.0" />
     <PackageReference Include="coverlet.msbuild" Version="6.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>