jnm2 · July 2, 2025 00:20
diff --git a/Nongeneric factories in top 8000 nuget packages.txt b/Nongeneric factories in top 8000 nuget packages.txt
 System.Tuple (System.Runtime 9.0.0.0):
 - Tuple<T1> Create<T1>(T1)

 System.Tuple (System.Runtime 9.0.0.0):
 - Tuple<T1, T2> Create<T1, T2>(T1, T2)

 System.Tuple (System.Runtime 9.0.0.0):
 - Tuple<T1, T2, T3> Create<T1, T2, T3>(T1, T2, T3)

 System.Tuple (System.Runtime 9.0.0.0):
 - Tuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1, T2, T3, T4)

 System.Tuple (System.Runtime 9.0.0.0):
 - Tuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1, T2, T3, T4, T5)

 System.Tuple (System.Runtime 9.0.0.0):
 - Tuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1, T2, T3, T4, T5, T6)

 System.Tuple (System.Runtime 9.0.0.0):
 - Tuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1, T2, T3, T4, T5, T6, T7)

 System.Tuple (System.Runtime 9.0.0.0):
 - Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1, T2, T3, T4, T5, T6, T7, T8)

 System.ValueTuple (System.Runtime 9.0.0.0):
 - ValueTuple<T1> Create<T1>(T1)

 System.ValueTuple (System.Runtime 9.0.0.0):
 - ValueTuple<T1, T2> Create<T1, T2>(T1, T2)

 System.ValueTuple (System.Runtime 9.0.0.0):
 - ValueTuple<T1, T2, T3> Create<T1, T2, T3>(T1, T2, T3)

 System.ValueTuple (System.Runtime 9.0.0.0):
 - ValueTuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1, T2, T3, T4)

 System.ValueTuple (System.Runtime 9.0.0.0):
 - ValueTuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1, T2, T3, T4, T5)

 System.ValueTuple (System.Runtime 9.0.0.0):
 - ValueTuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1, T2, T3, T4, T5, T6)

 System.ValueTuple (System.Runtime 9.0.0.0):
 - ValueTuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1, T2, T3, T4, T5, T6, T7)

 System.ValueTuple (System.Runtime 9.0.0.0):
 - ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8>> Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1, T2, T3, T4, T5, T6, T7, T8)

 System.Tuple (H5 0.0.0.0):
 - Tuple<T1> Create<T1>(T1)

 System.Tuple (H5 0.0.0.0):
 - Tuple<T1, T2> Create<T1, T2>(T1, T2)

 System.Tuple (H5 0.0.0.0):
 - Tuple<T1, T2, T3> Create<T1, T2, T3>(T1, T2, T3)

 System.Tuple (H5 0.0.0.0):
 - Tuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1, T2, T3, T4)

 System.Tuple (H5 0.0.0.0):
 - Tuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1, T2, T3, T4, T5)

 System.Tuple (H5 0.0.0.0):
 - Tuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1, T2, T3, T4, T5, T6)

 System.Tuple (H5 0.0.0.0):
 - Tuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1, T2, T3, T4, T5, T6, T7)

 System.Tuple (H5 0.0.0.0):
 - Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> Create<T1, T2, T3, T4, T5, T6, T7, TRest>(T1, T2, T3, T4, T5, T6, T7, TRest)

 System.ValueTuple (H5 0.0.0.0):
 - ValueTuple<T1> Create<T1>(T1)

 System.ValueTuple (H5 0.0.0.0):
 - ValueTuple<T1, T2> Create<T1, T2>(T1, T2)

 System.ValueTuple (H5 0.0.0.0):
 - ValueTuple<T1, T2, T3> Create<T1, T2, T3>(T1, T2, T3)

 System.ValueTuple (H5 0.0.0.0):
 - ValueTuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1, T2, T3, T4)

 System.ValueTuple (H5 0.0.0.0):
 - ValueTuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1, T2, T3, T4, T5)

 System.ValueTuple (H5 0.0.0.0):
 - ValueTuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1, T2, T3, T4, T5, T6)

 System.ValueTuple (H5 0.0.0.0):
 - ValueTuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1, T2, T3, T4, T5, T6, T7)

 System.ValueTuple (H5 0.0.0.0):
 - ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8>> Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1, T2, T3, T4, T5, T6, T7, T8)

 System.Tuple (Bridge 17.10.0.0):
 - Tuple<T1> Create<T1>(T1)

 System.Tuple (Bridge 17.10.0.0):
 - Tuple<T1, T2> Create<T1, T2>(T1, T2)

 System.Tuple (Bridge 17.10.0.0):
 - Tuple<T1, T2, T3> Create<T1, T2, T3>(T1, T2, T3)

 System.Tuple (Bridge 17.10.0.0):
 - Tuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1, T2, T3, T4)

 System.Tuple (Bridge 17.10.0.0):
 - Tuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1, T2, T3, T4, T5)

 System.Tuple (Bridge 17.10.0.0):
 - Tuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1, T2, T3, T4, T5, T6)

 System.Tuple (Bridge 17.10.0.0):
 - Tuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1, T2, T3, T4, T5, T6, T7)

 System.Tuple (Bridge 17.10.0.0):
 - Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> Create<T1, T2, T3, T4, T5, T6, T7, TRest>(T1, T2, T3, T4, T5, T6, T7, TRest)

 System.ValueTuple (Bridge 17.10.0.0):
 - ValueTuple<T1> Create<T1>(T1)

 System.ValueTuple (Bridge 17.10.0.0):
 - ValueTuple<T1, T2> Create<T1, T2>(T1, T2)

 System.ValueTuple (Bridge 17.10.0.0):
 - ValueTuple<T1, T2, T3> Create<T1, T2, T3>(T1, T2, T3)

 System.ValueTuple (Bridge 17.10.0.0):
 - ValueTuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1, T2, T3, T4)

 System.ValueTuple (Bridge 17.10.0.0):
 - ValueTuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1, T2, T3, T4, T5)

 System.ValueTuple (Bridge 17.10.0.0):
 - ValueTuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1, T2, T3, T4, T5, T6)

 System.ValueTuple (Bridge 17.10.0.0):
 - ValueTuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1, T2, T3, T4, T5, T6, T7)

 System.ValueTuple (Bridge 17.10.0.0):
 - ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8>> Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1, T2, T3, T4, T5, T6, T7, T8)

 System.Buffers.SearchValues (System.Runtime 9.0.0.0):
 - SearchValues<byte> Create(ReadOnlySpan<byte>)
 - SearchValues<char> Create(ReadOnlySpan<char>)
 - SearchValues<string> Create(ReadOnlySpan<string>, StringComparison)

 System.ClientModel.ClientResult (System.ClientModel 1.4.2.0):
 - ClientResult<T> FromValue<T>(T, PipelineResponse)
 - ClientResult<T> FromOptionalValue<T>(T, PipelineResponse)

 System.Collections.Frozen.FrozenDictionary (System.Collections.Immutable 9.0.0.0):
 - FrozenDictionary<TKey, TValue> ToFrozenDictionary<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>, IEqualityComparer<TKey>)
 - FrozenDictionary<TKey, TSource> ToFrozenDictionary<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>)
 - FrozenDictionary<TKey, TElement> ToFrozenDictionary<TSource, TKey, TElement>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)

 System.Collections.Frozen.FrozenSet (System.Collections.Immutable 9.0.0.0):
 - FrozenSet<T> Create<T>(ReadOnlySpan<T>)
 - FrozenSet<T> Create<T>(IEqualityComparer<T>, ReadOnlySpan<T>)
 - FrozenSet<T> ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)

 System.Collections.Generic.KeyValuePair (System.Runtime 9.0.0.0):
 - KeyValuePair<TKey, TValue> Create<TKey, TValue>(TKey, TValue)

 System.Collections.Generic.Enumerable.EnumerableIList (Ben.Demystifier 0.4.0.0):
 - EnumerableIList<T> Create<T>(IList<T>)

 System.Collections.Immutable.ImmutableArray (System.Collections.Immutable 9.0.0.0):
 - ImmutableArray<T> CreateRange<T>(IEnumerable<T>)
 - ImmutableArray<TResult> CreateRange<TSource, TResult>(ImmutableArray<TSource>, Func<TSource, TResult>)
 - ImmutableArray<TResult> CreateRange<TSource, TResult>(ImmutableArray<TSource>, int, int, Func<TSource, TResult>)
 - ImmutableArray<TResult> CreateRange<TSource, TArg, TResult>(ImmutableArray<TSource>, Func<TSource, TArg, TResult>, TArg)
 - ImmutableArray<TResult> CreateRange<TSource, TArg, TResult>(ImmutableArray<TSource>, int, int, Func<TSource, TArg, TResult>, TArg)
 - ImmutableArray<T> Create<T>()
 - ImmutableArray<T> Create<T>(ImmutableArray<T>, int, int)
 - ImmutableArray<T> Create<T>(T)
 - ImmutableArray<T> Create<T>(T, T)
 - ImmutableArray<T> Create<T>(T, T, T)
 - ImmutableArray<T> Create<T>(T, T, T, T)
 - ImmutableArray<T> Create<T>(T[])
 - ImmutableArray<T> Create<T>(T[], int, int)
 - ImmutableArray<T> Create<T>(ReadOnlySpan<T>)
 - ImmutableArray<T> Create<T>(Span<T>)
 - ImmutableArray<TSource> ToImmutableArray<TSource>(IEnumerable<TSource>)
 - ImmutableArray<TSource> ToImmutableArray<TSource>(Builder<TSource>)
 - ImmutableArray<T> ToImmutableArray<T>(ReadOnlySpan<T>)
 - ImmutableArray<T> ToImmutableArray<T>(Span<T>)

 System.Collections.Immutable.ImmutableDictionary (System.Collections.Immutable 9.0.0.0):
 - ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>)
 - ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEqualityComparer<TKey>, IEnumerable<KeyValuePair<TKey, TValue>>)
 - ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEqualityComparer<TKey>, IEqualityComparer<TValue>, IEnumerable<KeyValuePair<TKey, TValue>>)
 - ImmutableDictionary<TKey, TValue> Create<TKey, TValue>()
 - ImmutableDictionary<TKey, TValue> Create<TKey, TValue>(IEqualityComparer<TKey>)
 - ImmutableDictionary<TKey, TValue> Create<TKey, TValue>(IEqualityComparer<TKey>, IEqualityComparer<TValue>)
 - ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>)
 - ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>, IEqualityComparer<TKey>)
 - ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)
 - ImmutableDictionary<TKey, TSource> ToImmutableDictionary<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)
 - ImmutableDictionary<TKey, TSource> ToImmutableDictionary<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>)
 - ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(Builder<TKey, TValue>)
 - ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TValue>)
 - ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TValue>, IEqualityComparer<TKey>)
 - ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

 System.Collections.Immutable.ImmutableHashSet (System.Collections.Immutable 9.0.0.0):
 - ImmutableHashSet<T> CreateRange<T>(IEnumerable<T>)
 - ImmutableHashSet<T> CreateRange<T>(IEqualityComparer<T>, IEnumerable<T>)
 - ImmutableHashSet<T> Create<T>()
 - ImmutableHashSet<T> Create<T>(IEqualityComparer<T>)
 - ImmutableHashSet<T> Create<T>(IEqualityComparer<T>, T)
 - ImmutableHashSet<T> Create<T>(IEqualityComparer<T>, T[])
 - ImmutableHashSet<T> Create<T>(IEqualityComparer<T>, ReadOnlySpan<T>)
 - ImmutableHashSet<T> Create<T>(T)
 - ImmutableHashSet<T> Create<T>(T[])
 - ImmutableHashSet<T> Create<T>(ReadOnlySpan<T>)
 - ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(IEnumerable<TSource>)
 - ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)
 - ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(Builder<TSource>)

 System.Collections.Immutable.ImmutableList (System.Collections.Immutable 9.0.0.0):
 - ImmutableList<T> CreateRange<T>(IEnumerable<T>)
 - ImmutableList<T> Create<T>()
 - ImmutableList<T> Create<T>(T)
 - ImmutableList<T> Create<T>(T[])
 - ImmutableList<T> Create<T>(ReadOnlySpan<T>)
 - ImmutableList<TSource> ToImmutableList<TSource>(IEnumerable<TSource>)
 - ImmutableList<TSource> ToImmutableList<TSource>(Builder<TSource>)

 System.Collections.Immutable.ImmutableQueue (System.Collections.Immutable 9.0.0.0):
 - ImmutableQueue<T> CreateRange<T>(IEnumerable<T>)
 - ImmutableQueue<T> Create<T>()
 - ImmutableQueue<T> Create<T>(T)
 - ImmutableQueue<T> Create<T>(T[])
 - ImmutableQueue<T> Create<T>(ReadOnlySpan<T>)

 System.Collections.Immutable.ImmutableSortedDictionary (System.Collections.Immutable 9.0.0.0):
 - ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IComparer<TKey>, IEnumerable<KeyValuePair<TKey, TValue>>)
 - ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IComparer<TKey>, IEqualityComparer<TValue>, IEnumerable<KeyValuePair<TKey, TValue>>)
 - ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>)
 - ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>()
 - ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>(IComparer<TKey>)
 - ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>(IComparer<TKey>, IEqualityComparer<TValue>)
 - ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>)
 - ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>, IComparer<TKey>)
 - ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>, IComparer<TKey>, IEqualityComparer<TValue>)
 - ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(Builder<TKey, TValue>)
 - ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TValue>)
 - ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TValue>, IComparer<TKey>)
 - ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TValue>, IComparer<TKey>, IEqualityComparer<TValue>)

 System.Collections.Immutable.ImmutableSortedSet (System.Collections.Immutable 9.0.0.0):
 - ImmutableSortedSet<T> CreateRange<T>(IComparer<T>, IEnumerable<T>)
 - ImmutableSortedSet<T> CreateRange<T>(IEnumerable<T>)
 - ImmutableSortedSet<T> Create<T>()
 - ImmutableSortedSet<T> Create<T>(IComparer<T>)
 - ImmutableSortedSet<T> Create<T>(IComparer<T>, T)
 - ImmutableSortedSet<T> Create<T>(IComparer<T>, T[])
 - ImmutableSortedSet<T> Create<T>(IComparer<T>, ReadOnlySpan<T>)
 - ImmutableSortedSet<T> Create<T>(T)
 - ImmutableSortedSet<T> Create<T>(T[])
 - ImmutableSortedSet<T> Create<T>(ReadOnlySpan<T>)
 - ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(IEnumerable<TSource>)
 - ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)
 - ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(Builder<TSource>)

 System.Collections.Immutable.ImmutableStack (System.Collections.Immutable 9.0.0.0):
 - ImmutableStack<T> CreateRange<T>(IEnumerable<T>)
 - ImmutableStack<T> Create<T>()
 - ImmutableStack<T> Create<T>(T)
 - ImmutableStack<T> Create<T>(T[])
 - ImmutableStack<T> Create<T>(ReadOnlySpan<T>)

 System.Data.DataRowComparer (System.Data.Common 9.0.0.0):
 - DataRowComparer<DataRow> Default { get; }

 System.Linq.Expressions.Expression (System.Linq.Expressions 9.0.0.0):
 - Expression<TDelegate> Lambda<TDelegate>(Expression, bool, IEnumerable<ParameterExpression>)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, bool, ParameterExpression[])
 - Expression<TDelegate> Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression[])
 - Expression<TDelegate> Lambda<TDelegate>(Expression, string, bool, IEnumerable<ParameterExpression>)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, string, IEnumerable<ParameterExpression>)

 System.Linq.Expressions.Expression (H5 0.0.0.0):
 - Expression<TDelegate> Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression[])

 System.Linq.Expressions.Expression (Bridge 17.10.0.0):
 - Expression<TDelegate> Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression[])

 System.Net.ServerSentEvents.SseParser (System.Net.ServerSentEvents 9.0.0.6):
 - SseParser<string> Create(Stream)
 - SseParser<T> Create<T>(Stream, SseItemParser<T>)

 System.Numerics.Vector (System.Numerics.Vectors 9.0.0.0):
 - Vector<T> Abs<T>(Vector<T>)
 - Vector<T> Add<T>(Vector<T>, Vector<T>)
 - Vector<T> AndNot<T>(Vector<T>, Vector<T>)
 - Vector<TTo> As<TFrom, TTo>(Vector<TFrom>)
 - Vector<byte> AsVectorByte<T>(Vector<T>)
 - Vector<double> AsVectorDouble<T>(Vector<T>)
 - Vector<short> AsVectorInt16<T>(Vector<T>)
 - Vector<int> AsVectorInt32<T>(Vector<T>)
 - Vector<long> AsVectorInt64<T>(Vector<T>)
 - Vector<nint> AsVectorNInt<T>(Vector<T>)
 - Vector<nuint> AsVectorNUInt<T>(Vector<T>)
 - Vector<sbyte> AsVectorSByte<T>(Vector<T>)
 - Vector<float> AsVectorSingle<T>(Vector<T>)
 - Vector<ushort> AsVectorUInt16<T>(Vector<T>)
 - Vector<uint> AsVectorUInt32<T>(Vector<T>)
 - Vector<ulong> AsVectorUInt64<T>(Vector<T>)
 - Vector<T> BitwiseAnd<T>(Vector<T>, Vector<T>)
 - Vector<T> BitwiseOr<T>(Vector<T>, Vector<T>)
 - Vector<double> Ceiling(Vector<double>)
 - Vector<float> Ceiling(Vector<float>)
 - Vector<T> Clamp<T>(Vector<T>, Vector<T>, Vector<T>)
 - Vector<T> ClampNative<T>(Vector<T>, Vector<T>, Vector<T>)
 - Vector<float> ConditionalSelect(Vector<int>, Vector<float>, Vector<float>)
 - Vector<double> ConditionalSelect(Vector<long>, Vector<double>, Vector<double>)
 - Vector<T> ConditionalSelect<T>(Vector<T>, Vector<T>, Vector<T>)
 - Vector<double> ConvertToDouble(Vector<long>)
 - Vector<double> ConvertToDouble(Vector<ulong>)
 - Vector<int> ConvertToInt32(Vector<float>)
 - Vector<int> ConvertToInt32Native(Vector<float>)
 - Vector<long> ConvertToInt64(Vector<double>)
 - Vector<long> ConvertToInt64Native(Vector<double>)
 - Vector<float> ConvertToSingle(Vector<int>)
 - Vector<float> ConvertToSingle(Vector<uint>)
 - Vector<uint> ConvertToUInt32(Vector<float>)
 - Vector<uint> ConvertToUInt32Native(Vector<float>)
 - Vector<ulong> ConvertToUInt64(Vector<double>)
 - Vector<ulong> ConvertToUInt64Native(Vector<double>)
 - Vector<T> CopySign<T>(Vector<T>, Vector<T>)
 - Vector<double> Cos(Vector<double>)
 - Vector<float> Cos(Vector<float>)
 - Vector<T> Create<T>(T)
 - Vector<T> Create<T>(ReadOnlySpan<T>)
 - Vector<T> CreateSequence<T>(T, T)
 - Vector<double> DegreesToRadians(Vector<double>)
 - Vector<float> DegreesToRadians(Vector<float>)
 - Vector<T> Divide<T>(Vector<T>, Vector<T>)
 - Vector<T> Divide<T>(Vector<T>, T)
 - Vector<long> Equals(Vector<double>, Vector<double>)
 - Vector<int> Equals(Vector<int>, Vector<int>)
 - Vector<long> Equals(Vector<long>, Vector<long>)
 - Vector<int> Equals(Vector<float>, Vector<float>)
 - Vector<T> Equals<T>(Vector<T>, Vector<T>)
 - Vector<double> Exp(Vector<double>)
 - Vector<float> Exp(Vector<float>)
 - Vector<double> Floor(Vector<double>)
 - Vector<float> Floor(Vector<float>)
 - Vector<double> FusedMultiplyAdd(Vector<double>, Vector<double>, Vector<double>)
 - Vector<float> FusedMultiplyAdd(Vector<float>, Vector<float>, Vector<float>)
 - Vector<long> GreaterThan(Vector<double>, Vector<double>)
 - Vector<int> GreaterThan(Vector<int>, Vector<int>)
 - Vector<long> GreaterThan(Vector<long>, Vector<long>)
 - Vector<int> GreaterThan(Vector<float>, Vector<float>)
 - Vector<long> GreaterThanOrEqual(Vector<double>, Vector<double>)
 - Vector<int> GreaterThanOrEqual(Vector<int>, Vector<int>)
 - Vector<long> GreaterThanOrEqual(Vector<long>, Vector<long>)
 - Vector<int> GreaterThanOrEqual(Vector<float>, Vector<float>)
 - Vector<T> GreaterThanOrEqual<T>(Vector<T>, Vector<T>)
 - Vector<T> GreaterThan<T>(Vector<T>, Vector<T>)
 - Vector<double> Hypot(Vector<double>, Vector<double>)
 - Vector<float> Hypot(Vector<float>, Vector<float>)
 - Vector<T> IsNaN<T>(Vector<T>)
 - Vector<T> IsNegative<T>(Vector<T>)
 - Vector<T> IsPositive<T>(Vector<T>)
 - Vector<T> IsPositiveInfinity<T>(Vector<T>)
 - Vector<T> IsZero<T>(Vector<T>)
 - Vector<double> Lerp(Vector<double>, Vector<double>, Vector<double>)
 - Vector<float> Lerp(Vector<float>, Vector<float>, Vector<float>)
 - Vector<long> LessThan(Vector<double>, Vector<double>)
 - Vector<int> LessThan(Vector<int>, Vector<int>)
 - Vector<long> LessThan(Vector<long>, Vector<long>)
 - Vector<int> LessThan(Vector<float>, Vector<float>)
 - Vector<long> LessThanOrEqual(Vector<double>, Vector<double>)
 - Vector<int> LessThanOrEqual(Vector<int>, Vector<int>)
 - Vector<long> LessThanOrEqual(Vector<long>, Vector<long>)
 - Vector<int> LessThanOrEqual(Vector<float>, Vector<float>)
 - Vector<T> LessThanOrEqual<T>(Vector<T>, Vector<T>)
 - Vector<T> LessThan<T>(Vector<T>, Vector<T>)
 - Vector<T> Load<T>(T*)
 - Vector<T> LoadAligned<T>(T*)
 - Vector<T> LoadAlignedNonTemporal<T>(T*)
 - Vector<T> LoadUnsafe<T>(ref T)
 - Vector<T> LoadUnsafe<T>(ref T, nuint)
 - Vector<double> Log(Vector<double>)
 - Vector<float> Log(Vector<float>)
 - Vector<double> Log2(Vector<double>)
 - Vector<float> Log2(Vector<float>)
 - Vector<T> Max<T>(Vector<T>, Vector<T>)
 - Vector<T> MaxMagnitude<T>(Vector<T>, Vector<T>)
 - Vector<T> MaxMagnitudeNumber<T>(Vector<T>, Vector<T>)
 - Vector<T> MaxNative<T>(Vector<T>, Vector<T>)
 - Vector<T> MaxNumber<T>(Vector<T>, Vector<T>)
 - Vector<T> Min<T>(Vector<T>, Vector<T>)
 - Vector<T> MinMagnitude<T>(Vector<T>, Vector<T>)
 - Vector<T> MinMagnitudeNumber<T>(Vector<T>, Vector<T>)
 - Vector<T> MinNative<T>(Vector<T>, Vector<T>)
 - Vector<T> MinNumber<T>(Vector<T>, Vector<T>)
 - Vector<T> Multiply<T>(Vector<T>, Vector<T>)
 - Vector<T> Multiply<T>(Vector<T>, T)
 - Vector<T> Multiply<T>(T, Vector<T>)
 - Vector<double> MultiplyAddEstimate(Vector<double>, Vector<double>, Vector<double>)
 - Vector<float> MultiplyAddEstimate(Vector<float>, Vector<float>, Vector<float>)
 - Vector<float> Narrow(Vector<double>, Vector<double>)
 - Vector<sbyte> Narrow(Vector<short>, Vector<short>)
 - Vector<short> Narrow(Vector<int>, Vector<int>)
 - Vector<int> Narrow(Vector<long>, Vector<long>)
 - Vector<byte> Narrow(Vector<ushort>, Vector<ushort>)
 - Vector<ushort> Narrow(Vector<uint>, Vector<uint>)
 - Vector<uint> Narrow(Vector<ulong>, Vector<ulong>)
 - Vector<T> Negate<T>(Vector<T>)
 - Vector<T> OnesComplement<T>(Vector<T>)
 - Vector<double> RadiansToDegrees(Vector<double>)
 - Vector<float> RadiansToDegrees(Vector<float>)
 - Vector<double> Round(Vector<double>)
 - Vector<float> Round(Vector<float>)
 - Vector<double> Round(Vector<double>, MidpointRounding)
 - Vector<float> Round(Vector<float>, MidpointRounding)
 - Vector<byte> ShiftLeft(Vector<byte>, int)
 - Vector<short> ShiftLeft(Vector<short>, int)
 - Vector<int> ShiftLeft(Vector<int>, int)
 - Vector<long> ShiftLeft(Vector<long>, int)
 - Vector<nint> ShiftLeft(Vector<nint>, int)
 - Vector<nuint> ShiftLeft(Vector<nuint>, int)
 - Vector<sbyte> ShiftLeft(Vector<sbyte>, int)
 - Vector<ushort> ShiftLeft(Vector<ushort>, int)
 - Vector<uint> ShiftLeft(Vector<uint>, int)
 - Vector<ulong> ShiftLeft(Vector<ulong>, int)
 - Vector<short> ShiftRightArithmetic(Vector<short>, int)
 - Vector<int> ShiftRightArithmetic(Vector<int>, int)
 - Vector<long> ShiftRightArithmetic(Vector<long>, int)
 - Vector<nint> ShiftRightArithmetic(Vector<nint>, int)
 - Vector<sbyte> ShiftRightArithmetic(Vector<sbyte>, int)
 - Vector<byte> ShiftRightLogical(Vector<byte>, int)
 - Vector<short> ShiftRightLogical(Vector<short>, int)
 - Vector<int> ShiftRightLogical(Vector<int>, int)
 - Vector<long> ShiftRightLogical(Vector<long>, int)
 - Vector<nint> ShiftRightLogical(Vector<nint>, int)
 - Vector<nuint> ShiftRightLogical(Vector<nuint>, int)
 - Vector<sbyte> ShiftRightLogical(Vector<sbyte>, int)
 - Vector<ushort> ShiftRightLogical(Vector<ushort>, int)
 - Vector<uint> ShiftRightLogical(Vector<uint>, int)
 - Vector<ulong> ShiftRightLogical(Vector<ulong>, int)
 - Vector<double> Sin(Vector<double>)
 - Vector<float> Sin(Vector<float>)
 - Vector<T> SquareRoot<T>(Vector<T>)
 - Vector<T> Subtract<T>(Vector<T>, Vector<T>)
 - Vector<double> Truncate(Vector<double>)
 - Vector<float> Truncate(Vector<float>)
 - Vector<ushort> WidenLower(Vector<byte>)
 - Vector<int> WidenLower(Vector<short>)
 - Vector<long> WidenLower(Vector<int>)
 - Vector<short> WidenLower(Vector<sbyte>)
 - Vector<double> WidenLower(Vector<float>)
 - Vector<uint> WidenLower(Vector<ushort>)
 - Vector<ulong> WidenLower(Vector<uint>)
 - Vector<ushort> WidenUpper(Vector<byte>)
 - Vector<int> WidenUpper(Vector<short>)
 - Vector<long> WidenUpper(Vector<int>)
 - Vector<short> WidenUpper(Vector<sbyte>)
 - Vector<double> WidenUpper(Vector<float>)
 - Vector<uint> WidenUpper(Vector<ushort>)
 - Vector<ulong> WidenUpper(Vector<uint>)
 - Vector<T> WithElement<T>(Vector<T>, int, T)
 - Vector<T> Xor<T>(Vector<T>, Vector<T>)

 System.Numerics.Tensors.Tensor (System.Numerics.Tensors 9.0.0.6):
 - Tensor<T> Broadcast<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Broadcast<T>(ref ReadOnlyTensorSpan<T>, ReadOnlySpan<nint>)
 - Tensor<T> Concatenate<T>(ReadOnlySpan<Tensor<T>>)
 - Tensor<T> ConcatenateOnDimension<T>(int, ReadOnlySpan<Tensor<T>>)
 - Tensor<bool> Equals<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<bool> Equals<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<bool> GreaterThan<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<bool> GreaterThan<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<bool> GreaterThan<T>(T, ref ReadOnlyTensorSpan<T>)
 - Tensor<bool> GreaterThanOrEqual<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<bool> GreaterThanOrEqual<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<bool> GreaterThanOrEqual<T>(T, ref ReadOnlyTensorSpan<T>)
 - Tensor<bool> LessThan<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<bool> LessThan<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<bool> LessThan<T>(T, ref ReadOnlyTensorSpan<T>)
 - Tensor<bool> LessThanOrEqual<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<bool> LessThanOrEqual<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<bool> LessThanOrEqual<T>(T, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> PermuteDimensions<T>(Tensor<T>, ReadOnlySpan<int>)
 - Tensor<T> Reshape<T>(Tensor<T>, ReadOnlySpan<nint>)
 - Tensor<T> Resize<T>(Tensor<T>, ReadOnlySpan<nint>)
 - Tensor<T> Reverse<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> ReverseDimension<T>(ref ReadOnlyTensorSpan<T>, int)
 - Tensor<T> SetSlice<T>(Tensor<T>, ref ReadOnlyTensorSpan<T>, ReadOnlySpan<NRange>)
 - Tensor<T> Squeeze<T>(Tensor<T>)
 - Tensor<T> SqueezeDimension<T>(Tensor<T>, int)
 - Tensor<T> Stack<T>(ReadOnlySpan<Tensor<T>>)
 - Tensor<T> StackAlongDimension<T>(int, ReadOnlySpan<Tensor<T>>)
 - Tensor<T> Transpose<T>(Tensor<T>)
 - Tensor<T> Unsqueeze<T>(Tensor<T>, int)
 - Tensor<T> Abs<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Acos<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Acosh<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> AcosPi<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Add<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Add<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Asin<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Asinh<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> AsinPi<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Atan<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Atan2<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Atan2<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Atan2<T>(T, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Atan2Pi<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Atan2Pi<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Atan2Pi<T>(T, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Atanh<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> AtanPi<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> BitwiseAnd<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> BitwiseAnd<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> BitwiseOr<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> BitwiseOr<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Cbrt<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Ceiling<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<TTo> ConvertChecked<TFrom, TTo>(ref ReadOnlyTensorSpan<TFrom>)
 - Tensor<TTo> ConvertSaturating<TFrom, TTo>(ref ReadOnlyTensorSpan<TFrom>)
 - Tensor<TTo> ConvertTruncating<TFrom, TTo>(ref ReadOnlyTensorSpan<TFrom>)
 - Tensor<T> CopySign<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> CopySign<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Cos<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Cosh<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> CosineSimilarity<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> CosPi<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> DegreesToRadians<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Divide<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Divide<T>(T, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Divide<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Exp<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Exp10<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Exp10M1<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Exp2<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Exp2M1<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> ExpM1<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Floor<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Hypot<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Ieee754Remainder<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Ieee754Remainder<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Ieee754Remainder<T>(T, ref ReadOnlyTensorSpan<T>)
 - Tensor<int> ILogB<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> LeadingZeroCount<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Log<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Log<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Log<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Log10<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Log10P1<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Log2<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Log2P1<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> LogP1<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Max<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Max<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> MaxMagnitude<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> MaxMagnitude<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> MaxMagnitudeNumber<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> MaxMagnitudeNumber<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> MaxNumber<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> MaxNumber<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Min<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Min<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> MinMagnitude<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> MinMagnitude<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> MinMagnitudeNumber<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> MinMagnitudeNumber<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> MinNumber<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> MinNumber<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Multiply<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Multiply<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Negate<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> OnesComplement<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> PopCount<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Pow<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Pow<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Pow<T>(T, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> RadiansToDegrees<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Reciprocal<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> RootN<T>(ref ReadOnlyTensorSpan<T>, int)
 - Tensor<T> RotateLeft<T>(ref ReadOnlyTensorSpan<T>, int)
 - Tensor<T> RotateRight<T>(ref ReadOnlyTensorSpan<T>, int)
 - Tensor<T> Round<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Round<T>(ref ReadOnlyTensorSpan<T>, int, MidpointRounding)
 - Tensor<T> Round<T>(ref ReadOnlyTensorSpan<T>, int)
 - Tensor<T> Round<T>(ref ReadOnlyTensorSpan<T>, MidpointRounding)
 - Tensor<T> Sigmoid<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Sin<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Sinh<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> SinPi<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> SoftMax<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Sqrt<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Subtract<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Subtract<T>(T, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Subtract<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Tan<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Tanh<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> TanPi<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> TrailingZeroCount<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Truncate<T>(ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Xor<T>(ref ReadOnlyTensorSpan<T>, ref ReadOnlyTensorSpan<T>)
 - Tensor<T> Xor<T>(ref ReadOnlyTensorSpan<T>, T)
 - Tensor<T> Create<T>(ReadOnlySpan<nint>, bool)
 - Tensor<T> Create<T>(ReadOnlySpan<nint>, ReadOnlySpan<nint>, bool)
 - Tensor<T> Create<T>(T[], ReadOnlySpan<nint>, bool)
 - Tensor<T> Create<T>(T[], ReadOnlySpan<nint>, ReadOnlySpan<nint>, bool)
 - Tensor<T> Create<T>(IEnumerable<T>, ReadOnlySpan<nint>, bool)
 - Tensor<T> Create<T>(IEnumerable<T>, ReadOnlySpan<nint>, ReadOnlySpan<nint>, bool)
 - Tensor<T> CreateAndFillGaussianNormalDistribution<T>(ReadOnlySpan<nint>)
 - Tensor<T> CreateAndFillGaussianNormalDistribution<T>(Random, ReadOnlySpan<nint>)
 - Tensor<T> CreateAndFillUniformDistribution<T>(ReadOnlySpan<nint>)
 - Tensor<T> CreateAndFillUniformDistribution<T>(Random, ReadOnlySpan<nint>)
 - Tensor<T> CreateUninitialized<T>(ReadOnlySpan<nint>, bool)
 - Tensor<T> CreateUninitialized<T>(ReadOnlySpan<nint>, ReadOnlySpan<nint>, bool)

 System.Reactive.Notification (System.Reactive 6.0.0.0):
 - Notification<T> CreateOnNext<T>(T)
 - Notification<T> CreateOnError<T>(Exception)
 - Notification<T> CreateOnCompleted<T>()

 System.Reactive.Timestamped (System.Reactive 6.0.0.0):
 - Timestamped<T> Create<T>(T, DateTimeOffset)

 System.Runtime.Intrinsics.Vector128 (System.Runtime.Intrinsics 9.0.0.0):
 - Vector128<T> Abs<T>(Vector128<T>)
 - Vector128<T> Add<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> AndNot<T>(Vector128<T>, Vector128<T>)
 - Vector128<byte> AsByte<T>(Vector128<T>)
 - Vector128<double> AsDouble<T>(Vector128<T>)
 - Vector128<short> AsInt16<T>(Vector128<T>)
 - Vector128<int> AsInt32<T>(Vector128<T>)
 - Vector128<long> AsInt64<T>(Vector128<T>)
 - Vector128<nint> AsNInt<T>(Vector128<T>)
 - Vector128<nuint> AsNUInt<T>(Vector128<T>)
 - Vector128<sbyte> AsSByte<T>(Vector128<T>)
 - Vector128<float> AsSingle<T>(Vector128<T>)
 - Vector128<ushort> AsUInt16<T>(Vector128<T>)
 - Vector128<uint> AsUInt32<T>(Vector128<T>)
 - Vector128<ulong> AsUInt64<T>(Vector128<T>)
 - Vector128<float> AsVector128(Vector2)
 - Vector128<float> AsVector128(Vector3)
 - Vector128<float> AsVector128(Vector4)
 - Vector128<float> AsVector128Unsafe(Vector2)
 - Vector128<float> AsVector128Unsafe(Vector3)
 - Vector128<T> AsVector128<T>(Vector<T>)
 - Vector128<TTo> As<TFrom, TTo>(Vector128<TFrom>)
 - Vector128<T> BitwiseAnd<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> BitwiseOr<T>(Vector128<T>, Vector128<T>)
 - Vector128<double> Ceiling(Vector128<double>)
 - Vector128<float> Ceiling(Vector128<float>)
 - Vector128<T> Clamp<T>(Vector128<T>, Vector128<T>, Vector128<T>)
 - Vector128<T> ClampNative<T>(Vector128<T>, Vector128<T>, Vector128<T>)
 - Vector128<T> ConditionalSelect<T>(Vector128<T>, Vector128<T>, Vector128<T>)
 - Vector128<double> ConvertToDouble(Vector128<long>)
 - Vector128<double> ConvertToDouble(Vector128<ulong>)
 - Vector128<int> ConvertToInt32(Vector128<float>)
 - Vector128<int> ConvertToInt32Native(Vector128<float>)
 - Vector128<long> ConvertToInt64(Vector128<double>)
 - Vector128<long> ConvertToInt64Native(Vector128<double>)
 - Vector128<float> ConvertToSingle(Vector128<int>)
 - Vector128<float> ConvertToSingle(Vector128<uint>)
 - Vector128<uint> ConvertToUInt32(Vector128<float>)
 - Vector128<uint> ConvertToUInt32Native(Vector128<float>)
 - Vector128<ulong> ConvertToUInt64(Vector128<double>)
 - Vector128<ulong> ConvertToUInt64Native(Vector128<double>)
 - Vector128<T> CopySign<T>(Vector128<T>, Vector128<T>)
 - Vector128<double> Cos(Vector128<double>)
 - Vector128<float> Cos(Vector128<float>)
 - Vector128<byte> Create(byte)
 - Vector128<byte> Create(byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte)
 - Vector128<double> Create(double)
 - Vector128<double> Create(double, double)
 - Vector128<short> Create(short)
 - Vector128<short> Create(short, short, short, short, short, short, short, short)
 - Vector128<int> Create(int)
 - Vector128<int> Create(int, int, int, int)
 - Vector128<long> Create(long)
 - Vector128<long> Create(long, long)
 - Vector128<nint> Create(nint)
 - Vector128<nuint> Create(nuint)
 - Vector128<byte> Create(Vector64<byte>, Vector64<byte>)
 - Vector128<double> Create(Vector64<double>, Vector64<double>)
 - Vector128<short> Create(Vector64<short>, Vector64<short>)
 - Vector128<int> Create(Vector64<int>, Vector64<int>)
 - Vector128<long> Create(Vector64<long>, Vector64<long>)
 - Vector128<nint> Create(Vector64<nint>, Vector64<nint>)
 - Vector128<nuint> Create(Vector64<nuint>, Vector64<nuint>)
 - Vector128<sbyte> Create(Vector64<sbyte>, Vector64<sbyte>)
 - Vector128<float> Create(Vector64<float>, Vector64<float>)
 - Vector128<ushort> Create(Vector64<ushort>, Vector64<ushort>)
 - Vector128<uint> Create(Vector64<uint>, Vector64<uint>)
 - Vector128<ulong> Create(Vector64<ulong>, Vector64<ulong>)
 - Vector128<sbyte> Create(sbyte)
 - Vector128<sbyte> Create(sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte)
 - Vector128<float> Create(float)
 - Vector128<float> Create(float, float, float, float)
 - Vector128<ushort> Create(ushort)
 - Vector128<ushort> Create(ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort)
 - Vector128<uint> Create(uint)
 - Vector128<uint> Create(uint, uint, uint, uint)
 - Vector128<ulong> Create(ulong)
 - Vector128<ulong> Create(ulong, ulong)
 - Vector128<byte> CreateScalar(byte)
 - Vector128<double> CreateScalar(double)
 - Vector128<short> CreateScalar(short)
 - Vector128<int> CreateScalar(int)
 - Vector128<long> CreateScalar(long)
 - Vector128<nint> CreateScalar(nint)
 - Vector128<nuint> CreateScalar(nuint)
 - Vector128<sbyte> CreateScalar(sbyte)
 - Vector128<float> CreateScalar(float)
 - Vector128<ushort> CreateScalar(ushort)
 - Vector128<uint> CreateScalar(uint)
 - Vector128<ulong> CreateScalar(ulong)
 - Vector128<T> CreateScalar<T>(T)
 - Vector128<byte> CreateScalarUnsafe(byte)
 - Vector128<double> CreateScalarUnsafe(double)
 - Vector128<short> CreateScalarUnsafe(short)
 - Vector128<int> CreateScalarUnsafe(int)
 - Vector128<long> CreateScalarUnsafe(long)
 - Vector128<nint> CreateScalarUnsafe(nint)
 - Vector128<nuint> CreateScalarUnsafe(nuint)
 - Vector128<sbyte> CreateScalarUnsafe(sbyte)
 - Vector128<float> CreateScalarUnsafe(float)
 - Vector128<ushort> CreateScalarUnsafe(ushort)
 - Vector128<uint> CreateScalarUnsafe(uint)
 - Vector128<ulong> CreateScalarUnsafe(ulong)
 - Vector128<T> CreateScalarUnsafe<T>(T)
 - Vector128<T> CreateSequence<T>(T, T)
 - Vector128<T> Create<T>(ReadOnlySpan<T>)
 - Vector128<T> Create<T>(Vector64<T>)
 - Vector128<T> Create<T>(Vector64<T>, Vector64<T>)
 - Vector128<T> Create<T>(T)
 - Vector128<T> Create<T>(T[])
 - Vector128<T> Create<T>(T[], int)
 - Vector128<double> DegreesToRadians(Vector128<double>)
 - Vector128<float> DegreesToRadians(Vector128<float>)
 - Vector128<T> Divide<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> Divide<T>(Vector128<T>, T)
 - Vector128<T> Equals<T>(Vector128<T>, Vector128<T>)
 - Vector128<double> Exp(Vector128<double>)
 - Vector128<float> Exp(Vector128<float>)
 - Vector128<double> Floor(Vector128<double>)
 - Vector128<float> Floor(Vector128<float>)
 - Vector128<double> FusedMultiplyAdd(Vector128<double>, Vector128<double>, Vector128<double>)
 - Vector128<float> FusedMultiplyAdd(Vector128<float>, Vector128<float>, Vector128<float>)
 - Vector128<T> GreaterThanOrEqual<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> GreaterThan<T>(Vector128<T>, Vector128<T>)
 - Vector128<double> Hypot(Vector128<double>, Vector128<double>)
 - Vector128<float> Hypot(Vector128<float>, Vector128<float>)
 - Vector128<T> IsNaN<T>(Vector128<T>)
 - Vector128<T> IsNegative<T>(Vector128<T>)
 - Vector128<T> IsPositive<T>(Vector128<T>)
 - Vector128<T> IsPositiveInfinity<T>(Vector128<T>)
 - Vector128<T> IsZero<T>(Vector128<T>)
 - Vector128<double> Lerp(Vector128<double>, Vector128<double>, Vector128<double>)
 - Vector128<float> Lerp(Vector128<float>, Vector128<float>, Vector128<float>)
 - Vector128<T> LessThanOrEqual<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> LessThan<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> Load<T>(T*)
 - Vector128<T> LoadAligned<T>(T*)
 - Vector128<T> LoadAlignedNonTemporal<T>(T*)
 - Vector128<T> LoadUnsafe<T>(ref T)
 - Vector128<T> LoadUnsafe<T>(ref T, nuint)
 - Vector128<double> Log(Vector128<double>)
 - Vector128<float> Log(Vector128<float>)
 - Vector128<double> Log2(Vector128<double>)
 - Vector128<float> Log2(Vector128<float>)
 - Vector128<T> Max<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> MaxMagnitude<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> MaxMagnitudeNumber<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> MaxNative<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> MaxNumber<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> Min<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> MinMagnitude<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> MinMagnitudeNumber<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> MinNative<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> MinNumber<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> Multiply<T>(Vector128<T>, Vector128<T>)
 - Vector128<T> Multiply<T>(Vector128<T>, T)
 - Vector128<T> Multiply<T>(T, Vector128<T>)
 - Vector128<double> MultiplyAddEstimate(Vector128<double>, Vector128<double>, Vector128<double>)
 - Vector128<float> MultiplyAddEstimate(Vector128<float>, Vector128<float>, Vector128<float>)
 - Vector128<float> Narrow(Vector128<double>, Vector128<double>)
 - Vector128<sbyte> Narrow(Vector128<short>, Vector128<short>)
 - Vector128<short> Narrow(Vector128<int>, Vector128<int>)
 - Vector128<int> Narrow(Vector128<long>, Vector128<long>)
 - Vector128<byte> Narrow(Vector128<ushort>, Vector128<ushort>)
 - Vector128<ushort> Narrow(Vector128<uint>, Vector128<uint>)
 - Vector128<uint> Narrow(Vector128<ulong>, Vector128<ulong>)
 - Vector128<T> Negate<T>(Vector128<T>)
 - Vector128<T> OnesComplement<T>(Vector128<T>)
 - Vector128<double> RadiansToDegrees(Vector128<double>)
 - Vector128<float> RadiansToDegrees(Vector128<float>)
 - Vector128<double> Round(Vector128<double>)
 - Vector128<float> Round(Vector128<float>)
 - Vector128<double> Round(Vector128<double>, MidpointRounding)
 - Vector128<float> Round(Vector128<float>, MidpointRounding)
 - Vector128<byte> ShiftLeft(Vector128<byte>, int)
 - Vector128<short> ShiftLeft(Vector128<short>, int)
 - Vector128<int> ShiftLeft(Vector128<int>, int)
 - Vector128<long> ShiftLeft(Vector128<long>, int)
 - Vector128<nint> ShiftLeft(Vector128<nint>, int)
 - Vector128<nuint> ShiftLeft(Vector128<nuint>, int)
 - Vector128<sbyte> ShiftLeft(Vector128<sbyte>, int)
 - Vector128<ushort> ShiftLeft(Vector128<ushort>, int)
 - Vector128<uint> ShiftLeft(Vector128<uint>, int)
 - Vector128<ulong> ShiftLeft(Vector128<ulong>, int)
 - Vector128<short> ShiftRightArithmetic(Vector128<short>, int)
 - Vector128<int> ShiftRightArithmetic(Vector128<int>, int)
 - Vector128<long> ShiftRightArithmetic(Vector128<long>, int)
 - Vector128<nint> ShiftRightArithmetic(Vector128<nint>, int)
 - Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte>, int)
 - Vector128<byte> ShiftRightLogical(Vector128<byte>, int)
 - Vector128<short> ShiftRightLogical(Vector128<short>, int)
 - Vector128<int> ShiftRightLogical(Vector128<int>, int)
 - Vector128<long> ShiftRightLogical(Vector128<long>, int)
 - Vector128<nint> ShiftRightLogical(Vector128<nint>, int)
 - Vector128<nuint> ShiftRightLogical(Vector128<nuint>, int)
 - Vector128<sbyte> ShiftRightLogical(Vector128<sbyte>, int)
 - Vector128<ushort> ShiftRightLogical(Vector128<ushort>, int)
 - Vector128<uint> ShiftRightLogical(Vector128<uint>, int)
 - Vector128<ulong> ShiftRightLogical(Vector128<ulong>, int)
 - Vector128<byte> Shuffle(Vector128<byte>, Vector128<byte>)
 - Vector128<sbyte> Shuffle(Vector128<sbyte>, Vector128<sbyte>)
 - Vector128<short> Shuffle(Vector128<short>, Vector128<short>)
 - Vector128<ushort> Shuffle(Vector128<ushort>, Vector128<ushort>)
 - Vector128<int> Shuffle(Vector128<int>, Vector128<int>)
 - Vector128<uint> Shuffle(Vector128<uint>, Vector128<uint>)
 - Vector128<float> Shuffle(Vector128<float>, Vector128<int>)
 - Vector128<long> Shuffle(Vector128<long>, Vector128<long>)
 - Vector128<ulong> Shuffle(Vector128<ulong>, Vector128<ulong>)
 - Vector128<double> Shuffle(Vector128<double>, Vector128<long>)
 - Vector128<double> Sin(Vector128<double>)
 - Vector128<float> Sin(Vector128<float>)
 - Vector128<T> Sqrt<T>(Vector128<T>)
 - Vector128<T> Subtract<T>(Vector128<T>, Vector128<T>)
 - Vector128<double> Truncate(Vector128<double>)
 - Vector128<float> Truncate(Vector128<float>)
 - Vector128<ushort> WidenLower(Vector128<byte>)
 - Vector128<int> WidenLower(Vector128<short>)
 - Vector128<long> WidenLower(Vector128<int>)
 - Vector128<short> WidenLower(Vector128<sbyte>)
 - Vector128<double> WidenLower(Vector128<float>)
 - Vector128<uint> WidenLower(Vector128<ushort>)
 - Vector128<ulong> WidenLower(Vector128<uint>)
 - Vector128<ushort> WidenUpper(Vector128<byte>)
 - Vector128<int> WidenUpper(Vector128<short>)
 - Vector128<long> WidenUpper(Vector128<int>)
 - Vector128<short> WidenUpper(Vector128<sbyte>)
 - Vector128<double> WidenUpper(Vector128<float>)
 - Vector128<uint> WidenUpper(Vector128<ushort>)
 - Vector128<ulong> WidenUpper(Vector128<uint>)
 - Vector128<T> WithElement<T>(Vector128<T>, int, T)
 - Vector128<T> WithLower<T>(Vector128<T>, Vector64<T>)
 - Vector128<T> WithUpper<T>(Vector128<T>, Vector64<T>)
 - Vector128<T> Xor<T>(Vector128<T>, Vector128<T>)

 System.Runtime.Intrinsics.Vector256 (System.Runtime.Intrinsics 9.0.0.0):
 - Vector256<T> Abs<T>(Vector256<T>)
 - Vector256<T> Add<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> AndNot<T>(Vector256<T>, Vector256<T>)
 - Vector256<byte> AsByte<T>(Vector256<T>)
 - Vector256<double> AsDouble<T>(Vector256<T>)
 - Vector256<short> AsInt16<T>(Vector256<T>)
 - Vector256<int> AsInt32<T>(Vector256<T>)
 - Vector256<long> AsInt64<T>(Vector256<T>)
 - Vector256<nint> AsNInt<T>(Vector256<T>)
 - Vector256<nuint> AsNUInt<T>(Vector256<T>)
 - Vector256<sbyte> AsSByte<T>(Vector256<T>)
 - Vector256<float> AsSingle<T>(Vector256<T>)
 - Vector256<ushort> AsUInt16<T>(Vector256<T>)
 - Vector256<uint> AsUInt32<T>(Vector256<T>)
 - Vector256<ulong> AsUInt64<T>(Vector256<T>)
 - Vector256<T> AsVector256<T>(Vector<T>)
 - Vector256<TTo> As<TFrom, TTo>(Vector256<TFrom>)
 - Vector256<T> BitwiseAnd<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> BitwiseOr<T>(Vector256<T>, Vector256<T>)
 - Vector256<double> Ceiling(Vector256<double>)
 - Vector256<float> Ceiling(Vector256<float>)
 - Vector256<T> Clamp<T>(Vector256<T>, Vector256<T>, Vector256<T>)
 - Vector256<T> ClampNative<T>(Vector256<T>, Vector256<T>, Vector256<T>)
 - Vector256<T> ConditionalSelect<T>(Vector256<T>, Vector256<T>, Vector256<T>)
 - Vector256<double> ConvertToDouble(Vector256<long>)
 - Vector256<double> ConvertToDouble(Vector256<ulong>)
 - Vector256<int> ConvertToInt32(Vector256<float>)
 - Vector256<int> ConvertToInt32Native(Vector256<float>)
 - Vector256<long> ConvertToInt64(Vector256<double>)
 - Vector256<long> ConvertToInt64Native(Vector256<double>)
 - Vector256<float> ConvertToSingle(Vector256<int>)
 - Vector256<float> ConvertToSingle(Vector256<uint>)
 - Vector256<uint> ConvertToUInt32(Vector256<float>)
 - Vector256<uint> ConvertToUInt32Native(Vector256<float>)
 - Vector256<ulong> ConvertToUInt64(Vector256<double>)
 - Vector256<ulong> ConvertToUInt64Native(Vector256<double>)
 - Vector256<T> CopySign<T>(Vector256<T>, Vector256<T>)
 - Vector256<double> Cos(Vector256<double>)
 - Vector256<float> Cos(Vector256<float>)
 - Vector256<byte> Create(byte)
 - Vector256<byte> Create(byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte)
 - Vector256<double> Create(double)
 - Vector256<double> Create(double, double, double, double)
 - Vector256<short> Create(short)
 - Vector256<short> Create(short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short)
 - Vector256<int> Create(int)
 - Vector256<int> Create(int, int, int, int, int, int, int, int)
 - Vector256<long> Create(long)
 - Vector256<long> Create(long, long, long, long)
 - Vector256<nint> Create(nint)
 - Vector256<nuint> Create(nuint)
 - Vector256<byte> Create(Vector128<byte>, Vector128<byte>)
 - Vector256<double> Create(Vector128<double>, Vector128<double>)
 - Vector256<short> Create(Vector128<short>, Vector128<short>)
 - Vector256<int> Create(Vector128<int>, Vector128<int>)
 - Vector256<long> Create(Vector128<long>, Vector128<long>)
 - Vector256<nint> Create(Vector128<nint>, Vector128<nint>)
 - Vector256<nuint> Create(Vector128<nuint>, Vector128<nuint>)
 - Vector256<sbyte> Create(Vector128<sbyte>, Vector128<sbyte>)
 - Vector256<float> Create(Vector128<float>, Vector128<float>)
 - Vector256<ushort> Create(Vector128<ushort>, Vector128<ushort>)
 - Vector256<uint> Create(Vector128<uint>, Vector128<uint>)
 - Vector256<ulong> Create(Vector128<ulong>, Vector128<ulong>)
 - Vector256<sbyte> Create(sbyte)
 - Vector256<sbyte> Create(sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte)
 - Vector256<float> Create(float)
 - Vector256<float> Create(float, float, float, float, float, float, float, float)
 - Vector256<ushort> Create(ushort)
 - Vector256<ushort> Create(ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort)
 - Vector256<uint> Create(uint)
 - Vector256<uint> Create(uint, uint, uint, uint, uint, uint, uint, uint)
 - Vector256<ulong> Create(ulong)
 - Vector256<ulong> Create(ulong, ulong, ulong, ulong)
 - Vector256<byte> CreateScalar(byte)
 - Vector256<double> CreateScalar(double)
 - Vector256<short> CreateScalar(short)
 - Vector256<int> CreateScalar(int)
 - Vector256<long> CreateScalar(long)
 - Vector256<nint> CreateScalar(nint)
 - Vector256<nuint> CreateScalar(nuint)
 - Vector256<sbyte> CreateScalar(sbyte)
 - Vector256<float> CreateScalar(float)
 - Vector256<ushort> CreateScalar(ushort)
 - Vector256<uint> CreateScalar(uint)
 - Vector256<ulong> CreateScalar(ulong)
 - Vector256<T> CreateScalar<T>(T)
 - Vector256<byte> CreateScalarUnsafe(byte)
 - Vector256<double> CreateScalarUnsafe(double)
 - Vector256<short> CreateScalarUnsafe(short)
 - Vector256<int> CreateScalarUnsafe(int)
 - Vector256<long> CreateScalarUnsafe(long)
 - Vector256<nint> CreateScalarUnsafe(nint)
 - Vector256<nuint> CreateScalarUnsafe(nuint)
 - Vector256<sbyte> CreateScalarUnsafe(sbyte)
 - Vector256<float> CreateScalarUnsafe(float)
 - Vector256<ushort> CreateScalarUnsafe(ushort)
 - Vector256<uint> CreateScalarUnsafe(uint)
 - Vector256<ulong> CreateScalarUnsafe(ulong)
 - Vector256<T> CreateScalarUnsafe<T>(T)
 - Vector256<T> CreateSequence<T>(T, T)
 - Vector256<T> Create<T>(ReadOnlySpan<T>)
 - Vector256<T> Create<T>(Vector64<T>)
 - Vector256<T> Create<T>(Vector128<T>)
 - Vector256<T> Create<T>(Vector128<T>, Vector128<T>)
 - Vector256<T> Create<T>(T)
 - Vector256<T> Create<T>(T[])
 - Vector256<T> Create<T>(T[], int)
 - Vector256<double> DegreesToRadians(Vector256<double>)
 - Vector256<float> DegreesToRadians(Vector256<float>)
 - Vector256<T> Divide<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> Divide<T>(Vector256<T>, T)
 - Vector256<T> Equals<T>(Vector256<T>, Vector256<T>)
 - Vector256<double> Exp(Vector256<double>)
 - Vector256<float> Exp(Vector256<float>)
 - Vector256<double> Floor(Vector256<double>)
 - Vector256<float> Floor(Vector256<float>)
 - Vector256<double> FusedMultiplyAdd(Vector256<double>, Vector256<double>, Vector256<double>)
 - Vector256<float> FusedMultiplyAdd(Vector256<float>, Vector256<float>, Vector256<float>)
 - Vector256<T> GreaterThanOrEqual<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> GreaterThan<T>(Vector256<T>, Vector256<T>)
 - Vector256<double> Hypot(Vector256<double>, Vector256<double>)
 - Vector256<float> Hypot(Vector256<float>, Vector256<float>)
 - Vector256<T> IsNaN<T>(Vector256<T>)
 - Vector256<T> IsNegative<T>(Vector256<T>)
 - Vector256<T> IsPositive<T>(Vector256<T>)
 - Vector256<T> IsPositiveInfinity<T>(Vector256<T>)
 - Vector256<T> IsZero<T>(Vector256<T>)
 - Vector256<double> Lerp(Vector256<double>, Vector256<double>, Vector256<double>)
 - Vector256<float> Lerp(Vector256<float>, Vector256<float>, Vector256<float>)
 - Vector256<T> LessThanOrEqual<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> LessThan<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> Load<T>(T*)
 - Vector256<T> LoadAligned<T>(T*)
 - Vector256<T> LoadAlignedNonTemporal<T>(T*)
 - Vector256<T> LoadUnsafe<T>(ref T)
 - Vector256<T> LoadUnsafe<T>(ref T, nuint)
 - Vector256<double> Log(Vector256<double>)
 - Vector256<float> Log(Vector256<float>)
 - Vector256<double> Log2(Vector256<double>)
 - Vector256<float> Log2(Vector256<float>)
 - Vector256<T> Max<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> MaxMagnitude<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> MaxMagnitudeNumber<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> MaxNative<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> MaxNumber<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> Min<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> MinMagnitude<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> MinMagnitudeNumber<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> MinNative<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> MinNumber<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> Multiply<T>(Vector256<T>, Vector256<T>)
 - Vector256<T> Multiply<T>(Vector256<T>, T)
 - Vector256<T> Multiply<T>(T, Vector256<T>)
 - Vector256<double> MultiplyAddEstimate(Vector256<double>, Vector256<double>, Vector256<double>)
 - Vector256<float> MultiplyAddEstimate(Vector256<float>, Vector256<float>, Vector256<float>)
 - Vector256<float> Narrow(Vector256<double>, Vector256<double>)
 - Vector256<sbyte> Narrow(Vector256<short>, Vector256<short>)
 - Vector256<short> Narrow(Vector256<int>, Vector256<int>)
 - Vector256<int> Narrow(Vector256<long>, Vector256<long>)
 - Vector256<byte> Narrow(Vector256<ushort>, Vector256<ushort>)
 - Vector256<ushort> Narrow(Vector256<uint>, Vector256<uint>)
 - Vector256<uint> Narrow(Vector256<ulong>, Vector256<ulong>)
 - Vector256<T> Negate<T>(Vector256<T>)
 - Vector256<T> OnesComplement<T>(Vector256<T>)
 - Vector256<double> RadiansToDegrees(Vector256<double>)
 - Vector256<float> RadiansToDegrees(Vector256<float>)
 - Vector256<double> Round(Vector256<double>)
 - Vector256<float> Round(Vector256<float>)
 - Vector256<double> Round(Vector256<double>, MidpointRounding)
 - Vector256<float> Round(Vector256<float>, MidpointRounding)
 - Vector256<byte> ShiftLeft(Vector256<byte>, int)
 - Vector256<short> ShiftLeft(Vector256<short>, int)
 - Vector256<int> ShiftLeft(Vector256<int>, int)
 - Vector256<long> ShiftLeft(Vector256<long>, int)
 - Vector256<nint> ShiftLeft(Vector256<nint>, int)
 - Vector256<nuint> ShiftLeft(Vector256<nuint>, int)
 - Vector256<sbyte> ShiftLeft(Vector256<sbyte>, int)
 - Vector256<ushort> ShiftLeft(Vector256<ushort>, int)
 - Vector256<uint> ShiftLeft(Vector256<uint>, int)
 - Vector256<ulong> ShiftLeft(Vector256<ulong>, int)
 - Vector256<short> ShiftRightArithmetic(Vector256<short>, int)
 - Vector256<int> ShiftRightArithmetic(Vector256<int>, int)
 - Vector256<long> ShiftRightArithmetic(Vector256<long>, int)
 - Vector256<nint> ShiftRightArithmetic(Vector256<nint>, int)
 - Vector256<sbyte> ShiftRightArithmetic(Vector256<sbyte>, int)
 - Vector256<byte> ShiftRightLogical(Vector256<byte>, int)
 - Vector256<short> ShiftRightLogical(Vector256<short>, int)
 - Vector256<int> ShiftRightLogical(Vector256<int>, int)
 - Vector256<long> ShiftRightLogical(Vector256<long>, int)
 - Vector256<nint> ShiftRightLogical(Vector256<nint>, int)
 - Vector256<nuint> ShiftRightLogical(Vector256<nuint>, int)
 - Vector256<sbyte> ShiftRightLogical(Vector256<sbyte>, int)
 - Vector256<ushort> ShiftRightLogical(Vector256<ushort>, int)
 - Vector256<uint> ShiftRightLogical(Vector256<uint>, int)
 - Vector256<ulong> ShiftRightLogical(Vector256<ulong>, int)
 - Vector256<byte> Shuffle(Vector256<byte>, Vector256<byte>)
 - Vector256<sbyte> Shuffle(Vector256<sbyte>, Vector256<sbyte>)
 - Vector256<short> Shuffle(Vector256<short>, Vector256<short>)
 - Vector256<ushort> Shuffle(Vector256<ushort>, Vector256<ushort>)
 - Vector256<int> Shuffle(Vector256<int>, Vector256<int>)
 - Vector256<uint> Shuffle(Vector256<uint>, Vector256<uint>)
 - Vector256<float> Shuffle(Vector256<float>, Vector256<int>)
 - Vector256<long> Shuffle(Vector256<long>, Vector256<long>)
 - Vector256<ulong> Shuffle(Vector256<ulong>, Vector256<ulong>)
 - Vector256<double> Shuffle(Vector256<double>, Vector256<long>)
 - Vector256<double> Sin(Vector256<double>)
 - Vector256<float> Sin(Vector256<float>)
 - Vector256<T> Sqrt<T>(Vector256<T>)
 - Vector256<T> Subtract<T>(Vector256<T>, Vector256<T>)
 - Vector256<double> Truncate(Vector256<double>)
 - Vector256<float> Truncate(Vector256<float>)
 - Vector256<ushort> WidenLower(Vector256<byte>)
 - Vector256<int> WidenLower(Vector256<short>)
 - Vector256<long> WidenLower(Vector256<int>)
 - Vector256<short> WidenLower(Vector256<sbyte>)
 - Vector256<double> WidenLower(Vector256<float>)
 - Vector256<uint> WidenLower(Vector256<ushort>)
 - Vector256<ulong> WidenLower(Vector256<uint>)
 - Vector256<ushort> WidenUpper(Vector256<byte>)
 - Vector256<int> WidenUpper(Vector256<short>)
 - Vector256<long> WidenUpper(Vector256<int>)
 - Vector256<short> WidenUpper(Vector256<sbyte>)
 - Vector256<double> WidenUpper(Vector256<float>)
 - Vector256<uint> WidenUpper(Vector256<ushort>)
 - Vector256<ulong> WidenUpper(Vector256<uint>)
 - Vector256<T> WithElement<T>(Vector256<T>, int, T)
 - Vector256<T> WithLower<T>(Vector256<T>, Vector128<T>)
 - Vector256<T> WithUpper<T>(Vector256<T>, Vector128<T>)
 - Vector256<T> Xor<T>(Vector256<T>, Vector256<T>)

 System.Runtime.Intrinsics.Vector512 (System.Runtime.Intrinsics 9.0.0.0):
 - Vector512<T> Abs<T>(Vector512<T>)
 - Vector512<T> Add<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> AndNot<T>(Vector512<T>, Vector512<T>)
 - Vector512<byte> AsByte<T>(Vector512<T>)
 - Vector512<double> AsDouble<T>(Vector512<T>)
 - Vector512<short> AsInt16<T>(Vector512<T>)
 - Vector512<int> AsInt32<T>(Vector512<T>)
 - Vector512<long> AsInt64<T>(Vector512<T>)
 - Vector512<nint> AsNInt<T>(Vector512<T>)
 - Vector512<nuint> AsNUInt<T>(Vector512<T>)
 - Vector512<sbyte> AsSByte<T>(Vector512<T>)
 - Vector512<float> AsSingle<T>(Vector512<T>)
 - Vector512<ushort> AsUInt16<T>(Vector512<T>)
 - Vector512<uint> AsUInt32<T>(Vector512<T>)
 - Vector512<ulong> AsUInt64<T>(Vector512<T>)
 - Vector512<T> AsVector512<T>(Vector<T>)
 - Vector512<TTo> As<TFrom, TTo>(Vector512<TFrom>)
 - Vector512<T> BitwiseAnd<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> BitwiseOr<T>(Vector512<T>, Vector512<T>)
 - Vector512<double> Ceiling(Vector512<double>)
 - Vector512<float> Ceiling(Vector512<float>)
 - Vector512<T> Clamp<T>(Vector512<T>, Vector512<T>, Vector512<T>)
 - Vector512<T> ClampNative<T>(Vector512<T>, Vector512<T>, Vector512<T>)
 - Vector512<T> ConditionalSelect<T>(Vector512<T>, Vector512<T>, Vector512<T>)
 - Vector512<double> ConvertToDouble(Vector512<long>)
 - Vector512<double> ConvertToDouble(Vector512<ulong>)
 - Vector512<int> ConvertToInt32(Vector512<float>)
 - Vector512<int> ConvertToInt32Native(Vector512<float>)
 - Vector512<long> ConvertToInt64(Vector512<double>)
 - Vector512<long> ConvertToInt64Native(Vector512<double>)
 - Vector512<float> ConvertToSingle(Vector512<int>)
 - Vector512<float> ConvertToSingle(Vector512<uint>)
 - Vector512<uint> ConvertToUInt32(Vector512<float>)
 - Vector512<uint> ConvertToUInt32Native(Vector512<float>)
 - Vector512<ulong> ConvertToUInt64(Vector512<double>)
 - Vector512<ulong> ConvertToUInt64Native(Vector512<double>)
 - Vector512<T> CopySign<T>(Vector512<T>, Vector512<T>)
 - Vector512<double> Cos(Vector512<double>)
 - Vector512<float> Cos(Vector512<float>)
 - Vector512<byte> Create(byte)
 - Vector512<byte> Create(byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte, byte)
 - Vector512<double> Create(double)
 - Vector512<double> Create(double, double, double, double, double, double, double, double)
 - Vector512<short> Create(short)
 - Vector512<short> Create(short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short)
 - Vector512<int> Create(int)
 - Vector512<int> Create(int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int)
 - Vector512<long> Create(long)
 - Vector512<long> Create(long, long, long, long, long, long, long, long)
 - Vector512<nint> Create(nint)
 - Vector512<nuint> Create(nuint)
 - Vector512<byte> Create(Vector256<byte>, Vector256<byte>)
 - Vector512<double> Create(Vector256<double>, Vector256<double>)
 - Vector512<short> Create(Vector256<short>, Vector256<short>)
 - Vector512<int> Create(Vector256<int>, Vector256<int>)
 - Vector512<long> Create(Vector256<long>, Vector256<long>)
 - Vector512<nint> Create(Vector256<nint>, Vector256<nint>)
 - Vector512<nuint> Create(Vector256<nuint>, Vector256<nuint>)
 - Vector512<sbyte> Create(Vector256<sbyte>, Vector256<sbyte>)
 - Vector512<float> Create(Vector256<float>, Vector256<float>)
 - Vector512<ushort> Create(Vector256<ushort>, Vector256<ushort>)
 - Vector512<uint> Create(Vector256<uint>, Vector256<uint>)
 - Vector512<ulong> Create(Vector256<ulong>, Vector256<ulong>)
 - Vector512<sbyte> Create(sbyte)
 - Vector512<sbyte> Create(sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte)
 - Vector512<float> Create(float)
 - Vector512<float> Create(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)
 - Vector512<ushort> Create(ushort)
 - Vector512<ushort> Create(ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort, ushort)
 - Vector512<uint> Create(uint)
 - Vector512<uint> Create(uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint)
 - Vector512<ulong> Create(ulong)
 - Vector512<ulong> Create(ulong, ulong, ulong, ulong, ulong, ulong, ulong, ulong)
 - Vector512<byte> CreateScalar(byte)
 - Vector512<double> CreateScalar(double)
 - Vector512<short> CreateScalar(short)
 - Vector512<int> CreateScalar(int)
 - Vector512<long> CreateScalar(long)
 - Vector512<nint> CreateScalar(nint)
 - Vector512<nuint> CreateScalar(nuint)
 - Vector512<sbyte> CreateScalar(sbyte)
 - Vector512<float> CreateScalar(float)
 - Vector512<ushort> CreateScalar(ushort)
 - Vector512<uint> CreateScalar(uint)
 - Vector512<ulong> CreateScalar(ulong)
 - Vector512<T> CreateScalar<T>(T)
 - Vector512<byte> CreateScalarUnsafe(byte)
 - Vector512<double> CreateScalarUnsafe(double)
 - Vector512<short> CreateScalarUnsafe(short)
 - Vector512<int> CreateScalarUnsafe(int)
 - Vector512<long> CreateScalarUnsafe(long)
 - Vector512<nint> CreateScalarUnsafe(nint)
 - Vector512<nuint> CreateScalarUnsafe(nuint)
 - Vector512<sbyte> CreateScalarUnsafe(sbyte)
 - Vector512<float> CreateScalarUnsafe(float)
 - Vector512<ushort> CreateScalarUnsafe(ushort)
 - Vector512<uint> CreateScalarUnsafe(uint)
 - Vector512<ulong> CreateScalarUnsafe(ulong)
 - Vector512<T> CreateScalarUnsafe<T>(T)
 - Vector512<T> CreateSequence<T>(T, T)
 - Vector512<T> Create<T>(ReadOnlySpan<T>)
 - Vector512<T> Create<T>(Vector64<T>)
 - Vector512<T> Create<T>(Vector128<T>)
 - Vector512<T> Create<T>(Vector256<T>)
 - Vector512<T> Create<T>(Vector256<T>, Vector256<T>)
 - Vector512<T> Create<T>(T)
 - Vector512<T> Create<T>(T[])
 - Vector512<T> Create<T>(T[], int)
 - Vector512<double> DegreesToRadians(Vector512<double>)
 - Vector512<float> DegreesToRadians(Vector512<float>)
 - Vector512<T> Divide<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> Divide<T>(Vector512<T>, T)
 - Vector512<T> Equals<T>(Vector512<T>, Vector512<T>)
 - Vector512<double> Exp(Vector512<double>)
 - Vector512<float> Exp(Vector512<float>)
 - Vector512<double> Floor(Vector512<double>)
 - Vector512<float> Floor(Vector512<float>)
 - Vector512<double> FusedMultiplyAdd(Vector512<double>, Vector512<double>, Vector512<double>)
 - Vector512<float> FusedMultiplyAdd(Vector512<float>, Vector512<float>, Vector512<float>)
 - Vector512<T> GreaterThanOrEqual<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> GreaterThan<T>(Vector512<T>, Vector512<T>)
 - Vector512<double> Hypot(Vector512<double>, Vector512<double>)
 - Vector512<float> Hypot(Vector512<float>, Vector512<float>)
 - Vector512<T> IsNaN<T>(Vector512<T>)
 - Vector512<T> IsNegative<T>(Vector512<T>)
 - Vector512<T> IsPositive<T>(Vector512<T>)
 - Vector512<T> IsPositiveInfinity<T>(Vector512<T>)
 - Vector512<T> IsZero<T>(Vector512<T>)
 - Vector512<double> Lerp(Vector512<double>, Vector512<double>, Vector512<double>)
 - Vector512<float> Lerp(Vector512<float>, Vector512<float>, Vector512<float>)
 - Vector512<T> LessThanOrEqual<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> LessThan<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> Load<T>(T*)
 - Vector512<T> LoadAligned<T>(T*)
 - Vector512<T> LoadAlignedNonTemporal<T>(T*)
 - Vector512<T> LoadUnsafe<T>(ref T)
 - Vector512<T> LoadUnsafe<T>(ref T, nuint)
 - Vector512<double> Log(Vector512<double>)
 - Vector512<float> Log(Vector512<float>)
 - Vector512<double> Log2(Vector512<double>)
 - Vector512<float> Log2(Vector512<float>)
 - Vector512<T> Max<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> MaxMagnitude<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> MaxMagnitudeNumber<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> MaxNative<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> MaxNumber<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> Min<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> MinMagnitude<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> MinMagnitudeNumber<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> MinNative<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> MinNumber<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> Multiply<T>(Vector512<T>, Vector512<T>)
 - Vector512<T> Multiply<T>(Vector512<T>, T)
 - Vector512<T> Multiply<T>(T, Vector512<T>)
 - Vector512<double> MultiplyAddEstimate(Vector512<double>, Vector512<double>, Vector512<double>)
 - Vector512<float> MultiplyAddEstimate(Vector512<float>, Vector512<float>, Vector512<float>)
 - Vector512<float> Narrow(Vector512<double>, Vector512<double>)
 - Vector512<sbyte> Narrow(Vector512<short>, Vector512<short>)
 - Vector512<short> Narrow(Vector512<int>, Vector512<int>)
 - Vector512<int> Narrow(Vector512<long>, Vector512<long>)
 - Vector512<byte> Narrow(Vector512<ushort>, Vector512<ushort>)
 - Vector512<ushort> Narrow(Vector512<uint>, Vector512<uint>)
 - Vector512<uint> Narrow(Vector512<ulong>, Vector512<ulong>)
 - Vector512<T> Negate<T>(Vector512<T>)
 - Vector512<T> OnesComplement<T>(Vector512<T>)
 - Vector512<double> RadiansToDegrees(Vector512<double>)
 - Vector512<float> RadiansToDegrees(Vector512<float>)
 - Vector512<double> Round(Vector512<double>)
 - Vector512<float> Round(Vector512<float>)
 - Vector512<double> Round(Vector512<double>, MidpointRounding)
 - Vector512<float> Round(Vector512<float>, MidpointRounding)
 - Vector512<byte> ShiftLeft(Vector512<byte>, int)
 - Vector512<short> ShiftLeft(Vector512<short>, int)
 - Vector512<int> ShiftLeft(Vector512<int>, int)
 - Vector512<long> ShiftLeft(Vector512<long>, int)
 - Vector512<nint> ShiftLeft(Vector512<nint>, int)
 - Vector512<nuint> ShiftLeft(Vector512<nuint>, int)
 - Vector512<sbyte> ShiftLeft(Vector512<sbyte>, int)
 - Vector512<ushort> ShiftLeft(Vector512<ushort>, int)
 - Vector512<uint> ShiftLeft(Vector512<uint>, int)
 - Vector512<ulong> ShiftLeft(Vector512<ulong>, int)
 - Vector512<short> ShiftRightArithmetic(Vector512<short>, int)
 - Vector512<int> ShiftRightArithmetic(Vector512<int>, int)
 - Vector512<long> ShiftRightArithmetic(Vector512<long>, int)
 - Vector512<nint> ShiftRightArithmetic(Vector512<nint>, int)
 - Vector512<sbyte> ShiftRightArithmetic(Vector512<sbyte>, int)
 - Vector512<byte> ShiftRightLogical(Vector512<byte>, int)
 - Vector512<short> ShiftRightLogical(Vector512<short>, int)
 - Vector512<int> ShiftRightLogical(Vector512<int>, int)
 - Vector512<long> ShiftRightLogical(Vector512<long>, int)
 - Vector512<nint> ShiftRightLogical(Vector512<nint>, int)
 - Vector512<nuint> ShiftRightLogical(Vector512<nuint>, int)
 - Vector512<sbyte> ShiftRightLogical(Vector512<sbyte>, int)
 - Vector512<ushort> ShiftRightLogical(Vector512<ushort>, int)
 - Vector512<uint> ShiftRightLogical(Vector512<uint>, int)
 - Vector512<ulong> ShiftRightLogical(Vector512<ulong>, int)
 - Vector512<byte> Shuffle(Vector512<byte>, Vector512<byte>)
 - Vector512<sbyte> Shuffle(Vector512<sbyte>, Vector512<sbyte>)
 - Vector512<short> Shuffle(Vector512<short>, Vector512<short>)
 - Vector512<ushort> Shuffle(Vector512<ushort>, Vector512<ushort>)
 - Vector512<int> Shuffle(Vector512<int>, Vector512<int>)
 - Vector512<uint> Shuffle(Vector512<uint>, Vector512<uint>)
 - Vector512<float> Shuffle(Vector512<float>, Vector512<int>)
 - Vector512<long> Shuffle(Vector512<long>, Vector512<long>)
 - Vector512<ulong> Shuffle(Vector512<ulong>, Vector512<ulong>)
 - Vector512<double> Shuffle(Vector512<double>, Vector512<long>)
 - Vector512<double> Sin(Vector512<double>)
 - Vector512<float> Sin(Vector512<float>)
 - Vector512<T> Sqrt<T>(Vector512<T>)
 - Vector512<T> Subtract<T>(Vector512<T>, Vector512<T>)
 - Vector512<double> Truncate(Vector512<double>)
 - Vector512<float> Truncate(Vector512<float>)
 - Vector512<ushort> WidenLower(Vector512<byte>)
 - Vector512<int> WidenLower(Vector512<short>)
 - Vector512<long> WidenLower(Vector512<int>)
 - Vector512<short> WidenLower(Vector512<sbyte>)
 - Vector512<double> WidenLower(Vector512<float>)
 - Vector512<uint> WidenLower(Vector512<ushort>)
 - Vector512<ulong> WidenLower(Vector512<uint>)
 - Vector512<ushort> WidenUpper(Vector512<byte>)
 - Vector512<int> WidenUpper(Vector512<short>)
 - Vector512<long> WidenUpper(Vector512<int>)
 - Vector512<short> WidenUpper(Vector512<sbyte>)
 - Vector512<double> WidenUpper(Vector512<float>)
 - Vector512<uint> WidenUpper(Vector512<ushort>)
 - Vector512<ulong> WidenUpper(Vector512<uint>)
 - Vector512<T> WithElement<T>(Vector512<T>, int, T)
 - Vector512<T> WithLower<T>(Vector512<T>, Vector256<T>)
 - Vector512<T> WithUpper<T>(Vector512<T>, Vector256<T>)
 - Vector512<T> Xor<T>(Vector512<T>, Vector512<T>)

 System.Runtime.Intrinsics.Vector64 (System.Runtime.Intrinsics 9.0.0.0):
 - Vector64<T> Abs<T>(Vector64<T>)
 - Vector64<T> Add<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> AndNot<T>(Vector64<T>, Vector64<T>)
 - Vector64<byte> AsByte<T>(Vector64<T>)
 - Vector64<double> AsDouble<T>(Vector64<T>)
 - Vector64<short> AsInt16<T>(Vector64<T>)
 - Vector64<int> AsInt32<T>(Vector64<T>)
 - Vector64<long> AsInt64<T>(Vector64<T>)
 - Vector64<nint> AsNInt<T>(Vector64<T>)
 - Vector64<nuint> AsNUInt<T>(Vector64<T>)
 - Vector64<sbyte> AsSByte<T>(Vector64<T>)
 - Vector64<float> AsSingle<T>(Vector64<T>)
 - Vector64<ushort> AsUInt16<T>(Vector64<T>)
 - Vector64<uint> AsUInt32<T>(Vector64<T>)
 - Vector64<ulong> AsUInt64<T>(Vector64<T>)
 - Vector64<TTo> As<TFrom, TTo>(Vector64<TFrom>)
 - Vector64<T> BitwiseAnd<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> BitwiseOr<T>(Vector64<T>, Vector64<T>)
 - Vector64<double> Ceiling(Vector64<double>)
 - Vector64<float> Ceiling(Vector64<float>)
 - Vector64<T> Clamp<T>(Vector64<T>, Vector64<T>, Vector64<T>)
 - Vector64<T> ClampNative<T>(Vector64<T>, Vector64<T>, Vector64<T>)
 - Vector64<T> ConditionalSelect<T>(Vector64<T>, Vector64<T>, Vector64<T>)
 - Vector64<double> ConvertToDouble(Vector64<long>)
 - Vector64<double> ConvertToDouble(Vector64<ulong>)
 - Vector64<int> ConvertToInt32(Vector64<float>)
 - Vector64<int> ConvertToInt32Native(Vector64<float>)
 - Vector64<long> ConvertToInt64(Vector64<double>)
 - Vector64<long> ConvertToInt64Native(Vector64<double>)
 - Vector64<float> ConvertToSingle(Vector64<int>)
 - Vector64<float> ConvertToSingle(Vector64<uint>)
 - Vector64<uint> ConvertToUInt32(Vector64<float>)
 - Vector64<uint> ConvertToUInt32Native(Vector64<float>)
 - Vector64<ulong> ConvertToUInt64(Vector64<double>)
 - Vector64<ulong> ConvertToUInt64Native(Vector64<double>)
 - Vector64<T> CopySign<T>(Vector64<T>, Vector64<T>)
 - Vector64<double> Cos(Vector64<double>)
 - Vector64<float> Cos(Vector64<float>)
 - Vector64<byte> Create(byte)
 - Vector64<byte> Create(byte, byte, byte, byte, byte, byte, byte, byte)
 - Vector64<double> Create(double)
 - Vector64<short> Create(short)
 - Vector64<short> Create(short, short, short, short)
 - Vector64<int> Create(int)
 - Vector64<int> Create(int, int)
 - Vector64<long> Create(long)
 - Vector64<nint> Create(nint)
 - Vector64<nuint> Create(nuint)
 - Vector64<sbyte> Create(sbyte)
 - Vector64<sbyte> Create(sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte)
 - Vector64<float> Create(float)
 - Vector64<float> Create(float, float)
 - Vector64<ushort> Create(ushort)
 - Vector64<ushort> Create(ushort, ushort, ushort, ushort)
 - Vector64<uint> Create(uint)
 - Vector64<uint> Create(uint, uint)
 - Vector64<ulong> Create(ulong)
 - Vector64<byte> CreateScalar(byte)
 - Vector64<double> CreateScalar(double)
 - Vector64<short> CreateScalar(short)
 - Vector64<int> CreateScalar(int)
 - Vector64<long> CreateScalar(long)
 - Vector64<nint> CreateScalar(nint)
 - Vector64<nuint> CreateScalar(nuint)
 - Vector64<sbyte> CreateScalar(sbyte)
 - Vector64<float> CreateScalar(float)
 - Vector64<ushort> CreateScalar(ushort)
 - Vector64<uint> CreateScalar(uint)
 - Vector64<ulong> CreateScalar(ulong)
 - Vector64<T> CreateScalar<T>(T)
 - Vector64<byte> CreateScalarUnsafe(byte)
 - Vector64<double> CreateScalarUnsafe(double)
 - Vector64<short> CreateScalarUnsafe(short)
 - Vector64<int> CreateScalarUnsafe(int)
 - Vector64<long> CreateScalarUnsafe(long)
 - Vector64<nint> CreateScalarUnsafe(nint)
 - Vector64<nuint> CreateScalarUnsafe(nuint)
 - Vector64<sbyte> CreateScalarUnsafe(sbyte)
 - Vector64<float> CreateScalarUnsafe(float)
 - Vector64<ushort> CreateScalarUnsafe(ushort)
 - Vector64<uint> CreateScalarUnsafe(uint)
 - Vector64<ulong> CreateScalarUnsafe(ulong)
 - Vector64<T> CreateScalarUnsafe<T>(T)
 - Vector64<T> CreateSequence<T>(T, T)
 - Vector64<T> Create<T>(ReadOnlySpan<T>)
 - Vector64<T> Create<T>(T)
 - Vector64<T> Create<T>(T[])
 - Vector64<T> Create<T>(T[], int)
 - Vector64<double> DegreesToRadians(Vector64<double>)
 - Vector64<float> DegreesToRadians(Vector64<float>)
 - Vector64<T> Divide<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> Divide<T>(Vector64<T>, T)
 - Vector64<T> Equals<T>(Vector64<T>, Vector64<T>)
 - Vector64<double> Exp(Vector64<double>)
 - Vector64<float> Exp(Vector64<float>)
 - Vector64<double> Floor(Vector64<double>)
 - Vector64<float> Floor(Vector64<float>)
 - Vector64<double> FusedMultiplyAdd(Vector64<double>, Vector64<double>, Vector64<double>)
 - Vector64<float> FusedMultiplyAdd(Vector64<float>, Vector64<float>, Vector64<float>)
 - Vector64<T> GreaterThanOrEqual<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> GreaterThan<T>(Vector64<T>, Vector64<T>)
 - Vector64<double> Hypot(Vector64<double>, Vector64<double>)
 - Vector64<float> Hypot(Vector64<float>, Vector64<float>)
 - Vector64<T> IsNaN<T>(Vector64<T>)
 - Vector64<T> IsNegative<T>(Vector64<T>)
 - Vector64<T> IsPositive<T>(Vector64<T>)
 - Vector64<T> IsPositiveInfinity<T>(Vector64<T>)
 - Vector64<T> IsZero<T>(Vector64<T>)
 - Vector64<double> Lerp(Vector64<double>, Vector64<double>, Vector64<double>)
 - Vector64<float> Lerp(Vector64<float>, Vector64<float>, Vector64<float>)
 - Vector64<T> LessThanOrEqual<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> LessThan<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> Load<T>(T*)
 - Vector64<T> LoadAligned<T>(T*)
 - Vector64<T> LoadAlignedNonTemporal<T>(T*)
 - Vector64<T> LoadUnsafe<T>(ref T)
 - Vector64<T> LoadUnsafe<T>(ref T, nuint)
 - Vector64<double> Log(Vector64<double>)
 - Vector64<float> Log(Vector64<float>)
 - Vector64<double> Log2(Vector64<double>)
 - Vector64<float> Log2(Vector64<float>)
 - Vector64<T> Max<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> MaxMagnitude<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> MaxMagnitudeNumber<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> MaxNative<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> MaxNumber<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> Min<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> MinMagnitude<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> MinMagnitudeNumber<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> MinNative<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> MinNumber<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> Multiply<T>(Vector64<T>, Vector64<T>)
 - Vector64<T> Multiply<T>(Vector64<T>, T)
 - Vector64<T> Multiply<T>(T, Vector64<T>)
 - Vector64<double> MultiplyAddEstimate(Vector64<double>, Vector64<double>, Vector64<double>)
 - Vector64<float> MultiplyAddEstimate(Vector64<float>, Vector64<float>, Vector64<float>)
 - Vector64<float> Narrow(Vector64<double>, Vector64<double>)
 - Vector64<sbyte> Narrow(Vector64<short>, Vector64<short>)
 - Vector64<short> Narrow(Vector64<int>, Vector64<int>)
 - Vector64<int> Narrow(Vector64<long>, Vector64<long>)
 - Vector64<byte> Narrow(Vector64<ushort>, Vector64<ushort>)
 - Vector64<ushort> Narrow(Vector64<uint>, Vector64<uint>)
 - Vector64<uint> Narrow(Vector64<ulong>, Vector64<ulong>)
 - Vector64<T> Negate<T>(Vector64<T>)
 - Vector64<T> OnesComplement<T>(Vector64<T>)
 - Vector64<double> RadiansToDegrees(Vector64<double>)
 - Vector64<float> RadiansToDegrees(Vector64<float>)
 - Vector64<double> Round(Vector64<double>)
 - Vector64<float> Round(Vector64<float>)
 - Vector64<double> Round(Vector64<double>, MidpointRounding)
 - Vector64<float> Round(Vector64<float>, MidpointRounding)
 - Vector64<byte> ShiftLeft(Vector64<byte>, int)
 - Vector64<short> ShiftLeft(Vector64<short>, int)
 - Vector64<int> ShiftLeft(Vector64<int>, int)
 - Vector64<long> ShiftLeft(Vector64<long>, int)
 - Vector64<nint> ShiftLeft(Vector64<nint>, int)
 - Vector64<nuint> ShiftLeft(Vector64<nuint>, int)
 - Vector64<sbyte> ShiftLeft(Vector64<sbyte>, int)
 - Vector64<ushort> ShiftLeft(Vector64<ushort>, int)
 - Vector64<uint> ShiftLeft(Vector64<uint>, int)
 - Vector64<ulong> ShiftLeft(Vector64<ulong>, int)
 - Vector64<short> ShiftRightArithmetic(Vector64<short>, int)
 - Vector64<int> ShiftRightArithmetic(Vector64<int>, int)
 - Vector64<long> ShiftRightArithmetic(Vector64<long>, int)
 - Vector64<nint> ShiftRightArithmetic(Vector64<nint>, int)
 - Vector64<sbyte> ShiftRightArithmetic(Vector64<sbyte>, int)
 - Vector64<byte> ShiftRightLogical(Vector64<byte>, int)
 - Vector64<short> ShiftRightLogical(Vector64<short>, int)
 - Vector64<int> ShiftRightLogical(Vector64<int>, int)
 - Vector64<long> ShiftRightLogical(Vector64<long>, int)
 - Vector64<nint> ShiftRightLogical(Vector64<nint>, int)
 - Vector64<nuint> ShiftRightLogical(Vector64<nuint>, int)
 - Vector64<sbyte> ShiftRightLogical(Vector64<sbyte>, int)
 - Vector64<ushort> ShiftRightLogical(Vector64<ushort>, int)
 - Vector64<uint> ShiftRightLogical(Vector64<uint>, int)
 - Vector64<ulong> ShiftRightLogical(Vector64<ulong>, int)
 - Vector64<byte> Shuffle(Vector64<byte>, Vector64<byte>)
 - Vector64<sbyte> Shuffle(Vector64<sbyte>, Vector64<sbyte>)
 - Vector64<short> Shuffle(Vector64<short>, Vector64<short>)
 - Vector64<ushort> Shuffle(Vector64<ushort>, Vector64<ushort>)
 - Vector64<int> Shuffle(Vector64<int>, Vector64<int>)
 - Vector64<uint> Shuffle(Vector64<uint>, Vector64<uint>)
 - Vector64<float> Shuffle(Vector64<float>, Vector64<int>)
 - Vector64<double> Sin(Vector64<double>)
 - Vector64<float> Sin(Vector64<float>)
 - Vector64<T> Sqrt<T>(Vector64<T>)
 - Vector64<T> Subtract<T>(Vector64<T>, Vector64<T>)
 - Vector64<double> Truncate(Vector64<double>)
 - Vector64<float> Truncate(Vector64<float>)
 - Vector64<ushort> WidenLower(Vector64<byte>)
 - Vector64<int> WidenLower(Vector64<short>)
 - Vector64<long> WidenLower(Vector64<int>)
 - Vector64<short> WidenLower(Vector64<sbyte>)
 - Vector64<double> WidenLower(Vector64<float>)
 - Vector64<uint> WidenLower(Vector64<ushort>)
 - Vector64<ulong> WidenLower(Vector64<uint>)
 - Vector64<ushort> WidenUpper(Vector64<byte>)
 - Vector64<int> WidenUpper(Vector64<short>)
 - Vector64<long> WidenUpper(Vector64<int>)
 - Vector64<short> WidenUpper(Vector64<sbyte>)
 - Vector64<double> WidenUpper(Vector64<float>)
 - Vector64<uint> WidenUpper(Vector64<ushort>)
 - Vector64<ulong> WidenUpper(Vector64<uint>)
 - Vector64<T> WithElement<T>(Vector64<T>, int, T)
 - Vector64<T> Xor<T>(Vector64<T>, Vector64<T>)

 System.Text.Json.Serialization.Metadata.JsonTypeInfo (System.Text.Json 9.0.0.0):
 - JsonTypeInfo<T> CreateJsonTypeInfo<T>(JsonSerializerOptions)

 System.Threading.Channels.Channel (System.Threading.Channels 9.0.0.0):
 - Channel<T> CreateBounded<T>(int)
 - Channel<T> CreateBounded<T>(BoundedChannelOptions)
 - Channel<T> CreateBounded<T>(BoundedChannelOptions, Action<T>)
 - Channel<T> CreateUnbounded<T>()
 - Channel<T> CreateUnbounded<T>(UnboundedChannelOptions)
 - Channel<T> CreateUnboundedPrioritized<T>()
 - Channel<T> CreateUnboundedPrioritized<T>(UnboundedPrioritizedChannelOptions<T>)

 System.Threading.RateLimiting.MetadataName (System.Threading.RateLimiting 9.0.0.0):
 - MetadataName<T> Create<T>(string)
 - MetadataName<string> ReasonPhrase { get; }
 - MetadataName<TimeSpan> RetryAfter { get; }

 System.Threading.RateLimiting.PartitionedRateLimiter (System.Threading.RateLimiting 9.0.0.0):
 - PartitionedRateLimiter<TResource> CreateChained<TResource>(PartitionedRateLimiter<TResource>[])
 - PartitionedRateLimiter<TResource> Create<TResource, TPartitionKey>(Func<TResource, RateLimitPartition<TPartitionKey>>, IEqualityComparer<TPartitionKey>)

 System.Threading.RateLimiting.RateLimitPartition (System.Threading.RateLimiting 9.0.0.0):
 - RateLimitPartition<TKey> GetConcurrencyLimiter<TKey>(TKey, Func<TKey, ConcurrencyLimiterOptions>)
 - RateLimitPartition<TKey> GetFixedWindowLimiter<TKey>(TKey, Func<TKey, FixedWindowRateLimiterOptions>)
 - RateLimitPartition<TKey> GetNoLimiter<TKey>(TKey)
 - RateLimitPartition<TKey> GetSlidingWindowLimiter<TKey>(TKey, Func<TKey, SlidingWindowRateLimiterOptions>)
 - RateLimitPartition<TKey> GetTokenBucketLimiter<TKey>(TKey, Func<TKey, TokenBucketRateLimiterOptions>)
 - RateLimitPartition<TKey> Get<TKey>(TKey, Func<TKey, RateLimiter>)

 System.Threading.Tasks.Task (System.Runtime 9.0.0.0):
 - Task<TResult> FromCanceled<TResult>(CancellationToken)
 - Task<TResult> FromException<TResult>(Exception)
 - Task<TResult> FromResult<TResult>(TResult)
 - Task<TResult> Run<TResult>(Func<Task<TResult>>)
 - Task<TResult> Run<TResult>(Func<Task<TResult>>, CancellationToken)
 - Task<TResult> Run<TResult>(Func<TResult>)
 - Task<TResult> Run<TResult>(Func<TResult>, CancellationToken)
 - Task<TResult[]> WhenAll<TResult>(IEnumerable<Task<TResult>>)
 - Task<TResult[]> WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)
 - Task<TResult[]> WhenAll<TResult>(Task<TResult>[])
 - Task<Task> WhenAny(IEnumerable<Task>)
 - Task<Task> WhenAny(Task, Task)
 - Task<Task> WhenAny(ReadOnlySpan<Task>)
 - Task<Task> WhenAny(Task[])
 - Task<Task<TResult>> WhenAny<TResult>(IEnumerable<Task<TResult>>)
 - Task<Task<TResult>> WhenAny<TResult>(Task<TResult>, Task<TResult>)
 - Task<Task<TResult>> WhenAny<TResult>(ReadOnlySpan<Task<TResult>>)
 - Task<Task<TResult>> WhenAny<TResult>(Task<TResult>[])

 System.Threading.Tasks.ValueTask (System.Runtime 9.0.0.0):
 - ValueTask<TResult> FromCanceled<TResult>(CancellationToken)
 - ValueTask<TResult> FromException<TResult>(Exception)
 - ValueTask<TResult> FromResult<TResult>(TResult)

 System.Threading.Tasks.Task (H5 0.0.0.0):
 - Task<TResult> FromResult<TResult>(TResult)
 - Task<TResult> FromException<TResult>(Exception)
 - Task<TResult> Run<TResult>(Func<TResult>)
 - Task<TResult[]> WhenAll<TResult>(Task<TResult>[])
 - Task<TResult[]> WhenAll<TResult>(IEnumerable<Task<TResult>>)
 - Task<Task> WhenAny(Task[])
 - Task<Task> WhenAny(IEnumerable<Task>)
 - Task<Task<TResult>> WhenAny<TResult>(Task<TResult>[])
 - Task<Task<TResult>> WhenAny<TResult>(IEnumerable<Task<TResult>>)
 - Task<TResult> FromCallback<TResult>(object, string, object[])
 - Task<TResult> FromCallbackResult<TResult>(object, string, Delegate, object[])
 - Task<object[]> FromPromise(IPromise)
 - Task<TResult> FromPromise<TResult>(IPromise, Delegate)
 - Task<TResult> FromPromise<TResult>(IPromise, Delegate, Delegate)
 - Task<TResult> FromPromise<TResult>(IPromise, Delegate, Delegate, Delegate)

 System.Threading.Tasks.Task (Bridge 17.10.0.0):
 - Task<TResult> FromResult<TResult>(TResult)
 - Task<TResult> Run<TResult>(Func<TResult>)
 - Task<TResult[]> WhenAll<TResult>(Task<TResult>[])
 - Task<TResult[]> WhenAll<TResult>(IEnumerable<Task<TResult>>)
 - Task<Task> WhenAny(Task[])
 - Task<Task> WhenAny(IEnumerable<Task>)
 - Task<Task<TResult>> WhenAny<TResult>(Task<TResult>[])
 - Task<Task<TResult>> WhenAny<TResult>(IEnumerable<Task<TResult>>)
 - Task<TResult> FromCallback<TResult>(object, string, object[])
 - Task<TResult> FromCallbackResult<TResult>(object, string, Delegate, object[])
 - Task<object[]> FromPromise(IPromise)
 - Task<TResult> FromPromise<TResult>(IPromise, Delegate)
 - Task<TResult> FromPromise<TResult>(IPromise, Delegate, Delegate)
 - Task<TResult> FromPromise<TResult>(IPromise, Delegate, Delegate, Delegate)

 System.Web.Http.SingleResult (System.Web.Http 5.2.6.0):
 - SingleResult<T> Create<T>(IQueryable<T>)

 Microsoft.AspNetCore.OData.Results.SingleResult (Microsoft.AspNetCore.OData 9.3.2.0):
 - SingleResult<T> Create<T>(IQueryable<T>)

 Microsoft.ClearScript.ValueRef (ClearScript.Core 7.5.0.0):
 - ValueRef<T> Create<T>(T)

 Microsoft.Extensions.ObjectPool.ObjectPool (Microsoft.Extensions.ObjectPool 9.0.0.0):
 - ObjectPool<T> Create<T>(IPooledObjectPolicy<T>)

 Microsoft.FSharp.Collections.FSharpList (FSharp.Core 9.0.0.0):
 - FSharpList<T> Create<T>(ReadOnlySpan<T>)

 Microsoft.FSharp.Collections.FSharpSet (FSharp.Core 9.0.0.0):
 - FSharpSet<T> Create<T>(ReadOnlySpan<T>)

 Microsoft.FSharp.Control.FSharpAsync (FSharp.Core 9.0.0.0):
 - FSharpAsync<T> FromContinuations<T>(FSharpFunc<Tuple<FSharpFunc<T, Unit>, FSharpFunc<Exception, Unit>, FSharpFunc<OperationCanceledException, Unit>>, Unit>)
 - FSharpAsync<FSharpChoice<T, Exception>> Catch<T>(FSharpAsync<T>)
 - FSharpAsync<Task<T>> StartChildAsTask<T>(FSharpAsync<T>, FSharpOption<TaskCreationOptions>)
 - FSharpAsync<T[]> Parallel<T>(IEnumerable<FSharpAsync<T>>)
 - FSharpAsync<T[]> Parallel<T>(IEnumerable<FSharpAsync<T>>, FSharpOption<int>)
 - FSharpAsync<T[]> Sequential<T>(IEnumerable<FSharpAsync<T>>)
 - FSharpAsync<FSharpOption<T>> Choice<T>(IEnumerable<FSharpAsync<FSharpOption<T>>>)
 - FSharpAsync<Unit> Sleep(int)
 - FSharpAsync<Unit> Sleep(TimeSpan)
 - FSharpAsync<bool> AwaitWaitHandle(WaitHandle, FSharpOption<int>)
 - FSharpAsync<bool> AwaitIAsyncResult(IAsyncResult, FSharpOption<int>)
 - FSharpAsync<T> FromBeginEnd<T>(FSharpFunc<Tuple<AsyncCallback, object>, IAsyncResult>, FSharpFunc<IAsyncResult, T>, FSharpOption<FSharpFunc<Unit, Unit>>)
 - FSharpAsync<T> FromBeginEnd<TArg1, T>(TArg1, FSharpFunc<Tuple<TArg1, AsyncCallback, object>, IAsyncResult>, FSharpFunc<IAsyncResult, T>, FSharpOption<FSharpFunc<Unit, Unit>>)
 - FSharpAsync<T> FromBeginEnd<TArg1, TArg2, T>(TArg1, TArg2, FSharpFunc<Tuple<TArg1, TArg2, AsyncCallback, object>, IAsyncResult>, FSharpFunc<IAsyncResult, T>, FSharpOption<FSharpFunc<Unit, Unit>>)
 - FSharpAsync<T> FromBeginEnd<TArg1, TArg2, TArg3, T>(TArg1, TArg2, TArg3, FSharpFunc<Tuple<TArg1, TArg2, TArg3, AsyncCallback, object>, IAsyncResult>, FSharpFunc<IAsyncResult, T>, FSharpOption<FSharpFunc<Unit, Unit>>)
 - FSharpAsync<T> AwaitEvent<TDel, T>(IEvent<TDel, T>, FSharpOption<FSharpFunc<Unit, Unit>>)
 - FSharpAsync<Unit> Ignore<T>(FSharpAsync<T>)
 - FSharpAsync<Unit> SwitchToNewThread()
 - FSharpAsync<Unit> SwitchToThreadPool()
 - FSharpAsync<FSharpAsync<T>> StartChild<T>(FSharpAsync<T>, FSharpOption<int>)
 - FSharpAsync<Unit> SwitchToContext(SynchronizationContext)
 - FSharpAsync<IDisposable> OnCancel(FSharpFunc<Unit, Unit>)
 - FSharpAsync<T> TryCancelled<T>(FSharpAsync<T>, FSharpFunc<OperationCanceledException, Unit>)
 - FSharpAsync<T> AwaitTask<T>(Task<T>)
 - FSharpAsync<Unit> AwaitTask(Task)
 - FSharpAsync<CancellationToken> CancellationToken { get; }

 Microsoft.FSharp.Core.CompilerServices.ResumableCode (FSharp.Core 9.0.0.0):
 - ResumableCode<TData, T> Delay<TData, T>(FSharpFunc<Unit, ResumableCode<TData, T>>)
 - ResumableCode<TData, Unit> Zero<TData>()
 - ResumableCode<TData, T> Combine<TData, T>(ResumableCode<TData, Unit>, ResumableCode<TData, T>)
 - ResumableCode<TData, Unit> While<TData>(FSharpFunc<Unit, bool>, ResumableCode<TData, Unit>)
 - ResumableCode<TData, T> TryWith<TData, T>(ResumableCode<TData, T>, FSharpFunc<Exception, ResumableCode<TData, T>>)
 - ResumableCode<TData, T> TryFinally<TData, T>(ResumableCode<TData, T>, ResumableCode<TData, Unit>)
 - ResumableCode<TData, T> TryFinallyAsync<TData, T>(ResumableCode<TData, T>, ResumableCode<TData, Unit>)
 - ResumableCode<TData, T> Using<TResource, TData, T>(TResource, FSharpFunc<TResource, ResumableCode<TData, T>>)
 - ResumableCode<TData, Unit> For<T, TData>(IEnumerable<T>, FSharpFunc<T, ResumableCode<TData, Unit>>)
 - ResumableCode<TData, Unit> Yield<TData>()

 Microsoft.FSharp.Quotations.FSharpExpr (FSharp.Core 9.0.0.0):
 - FSharpExpr<T> WithValue<T>(T, FSharpExpr<T>)
 - FSharpExpr<T> Cast<T>(FSharpExpr)
 - FSharpExpr<T> GlobalVar<T>(string)

 Microsoft.JSInterop.DotNetObjectReference (Microsoft.JSInterop 9.0.0.0):
 - DotNetObjectReference<TValue> Create<TValue>(TValue)

 Microsoft.Maui.Controls.Internals.Registrar (Microsoft.Maui.Controls 1.0.0.0):
 - Registrar<IRegisterable> Registered { get; set; }

 Microsoft.ML.Data.VBufferEditor (Microsoft.ML.DataView 1.0.0.0):
 - VBufferEditor<T> CreateFromBuffer<T>(ref VBuffer<T>)
 - VBufferEditor<T> Create<T>(ref VBuffer<T>, int, Nullable<int>, Nullable<int>, bool, bool)

 Microsoft.ML.Data.AnomalyPredictionTransformer (Microsoft.ML.Data 1.0.0.0):
 - AnomalyPredictionTransformer<IPredictorProducing<float>> Create(IHostEnvironment, ModelLoadContext)

 Microsoft.ML.Data.ClusteringPredictionTransformer (Microsoft.ML.Data 1.0.0.0):
 - ClusteringPredictionTransformer<IPredictorProducing<VBuffer<float>>> Create(IHostEnvironment, ModelLoadContext)

 Microsoft.ML.OnnxRuntime.Tensors.Tensor (Microsoft.ML.OnnxRuntime 0.0.0.0):
 - Tensor<T> CreateIdentity<T>(int)
 - Tensor<T> CreateIdentity<T>(int, bool)
 - Tensor<T> CreateIdentity<T>(int, bool, T)
 - Tensor<T> CreateFromDiagonal<T>(Tensor<T>)
 - Tensor<T> CreateFromDiagonal<T>(Tensor<T>, int)

 Microsoft.TeamFoundation.Framework.Common.Capture (Microsoft.TeamFoundation.Common 19.0.0.0):
 - Capture<T> Create<T>(T, Predicate<T>)

 Microsoft.VisualStudio.Settings.StoreLogPropertyDefinition (Microsoft.VisualStudio.Utilities 17.0.0.0):
 - StoreLogPropertyDefinition<string> Source { get; }
 - StoreLogPropertyDefinition<Nullable<int>> OnlineRevision { get; }
 - StoreLogPropertyDefinition<Nullable<int>> LocalRevision { get; }
 - StoreLogPropertyDefinition<string> ListMergeBaseline { get; }
 - StoreLogPropertyDefinition<string> CanonicalRepresentation { get; }
 - StoreLogPropertyDefinition<Nullable<bool>> IsRoamingEnabled { get; }
 - StoreLogPropertyDefinition<Nullable<bool>> IsRoamable { get; }

 Microsoft.VisualStudio.Utilities.PooledSpan (Microsoft.VisualStudio.Utilities 17.0.0.0):
 - PooledSpan<T> Create<T>(int, bool, ArrayPool<T>)
 - PooledSpan<T> Create<T>(IEnumerable<T>, bool, ArrayPool<T>)

 Microsoft.VisualStudio.Utilities.UnifiedSettings.ExternalSettingOperationResult (Microsoft.VisualStudio.Utilities 17.0.0.0):
 - ExternalSettingOperationResult<T> SuccessResult<T>(T)
 - ExternalSettingOperationResult<T> ConvertSuccessResult<T>(object)

 Aardvark.Base.Tup (Aardvark.Base 5.3.0.0):
 - Tup<T0, T1> Create<T0, T1>(T0, T1)

 Aardvark.Base.Tup (Aardvark.Base 5.3.0.0):
 - Tup<T0, T1, T2> Create<T0, T1, T2>(T0, T1, T2)

 Aardvark.Base.Tup (Aardvark.Base 5.3.0.0):
 - Tup<T0, T1, T2, T3> Create<T0, T1, T2, T3>(T0, T1, T2, T3)

 Aardvark.Base.Tup (Aardvark.Base 5.3.0.0):
 - Tup<T0, T1, T2, T3, T4> Create<T0, T1, T2, T3, T4>(T0, T1, T2, T3, T4)

 Aardvark.Base.Tup (Aardvark.Base 5.3.0.0):
 - Tup<T0, T1, T2, T3, T4, T5> Create<T0, T1, T2, T3, T4, T5>(T0, T1, T2, T3, T4, T5)

 Aardvark.Base.Tup (Aardvark.Base 5.3.0.0):
 - Tup<T0, T1, T2, T3, T4, T5, T6> Create<T0, T1, T2, T3, T4, T5, T6>(T0, T1, T2, T3, T4, T5, T6)

 Aardvark.Base.Tup (Aardvark.Base 5.3.0.0):
 - Tup<T0, T1, T2, T3, T4, T5, T6, T7> Create<T0, T1, T2, T3, T4, T5, T6, T7>(T0, T1, T2, T3, T4, T5, T6, T7)

 Aardvark.Base.Tup (Aardvark.Base 5.3.0.0):
 - Tup<T0, T1, T2, T3, T4, T5, T6, T7, T8> Create<T0, T1, T2, T3, T4, T5, T6, T7, T8>(T0, T1, T2, T3, T4, T5, T6, T7, T8)

 Aardvark.Base.Tup (Aardvark.Base 5.3.0.0):
 - Tup<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Create<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

 Aardvark.Base.SortedList (Aardvark.Base.FSharp 5.3.0.0):
 - SortedList<a> empty<a>()
 - SortedList<a> add<a>(a, SortedList<a>)
 - SortedList<a> remove<a>(a, SortedList<a>)
 - SortedList<a> ofSeq<a>(IEnumerable<a>)
 - SortedList<a> ofList<a>(FSharpList<a>)
 - SortedList<a> ofArray<a>(a[])

 Aardvark.Base.FingerTreeImplementation+Affix (Aardvark.Base.FSharp 5.3.0.0):
 - Affix<a> one<a>(a)
 - Affix<a> two<a>(a, a)
 - Affix<a> three<a>(a, a, a)
 - Affix<a> four<a>(a, a, a, a)
 - Affix<a> prepend<a>(a, Affix<a>)
 - Affix<a> append<a>(a, Affix<a>)
 - Affix<a> ofNode<a, m>(Node<a, m>)
 - Affix<a> ofList<a>(FSharpList<a>)

 Aardvark.Base.FingerTreeImplementation+Node (Aardvark.Base.FSharp 5.3.0.0):
 - Node<a, m> two<a, m>(Measure<a, m>, a, a)
 - Node<a, m> three<a, m>(Measure<a, m>, a, a, a)
 - Node<a, m> ofAffix<a, m>(Measure<a, m>, Affix<a>)
 - Node<a, m> ofList<a, m>(Measure<a, m>, FSharpList<a>)

 Aardvark.Base.FingerTreeImplementation+FingerTreeNode (Aardvark.Base.FSharp 5.3.0.0):
 - FingerTreeNode<a, m> prepend<a, m>(Measure<a, m>, a, FingerTreeNode<a, m>)
 - FingerTreeNode<a, m> append<a, m>(Measure<a, m>, a, FingerTreeNode<a, m>)
 - FingerTreeNode<a, m> ofAffix<a, m>(Measure<a, m>, Affix<a>)
 - FingerTreeNode<a, m> ofOptAffix<a, m>(Measure<a, m>, FSharpOption<Affix<a>>)
 - FingerTreeNode<a, m> tail<a, m>(Measure<a, m>, FingerTreeNode<a, m>)
 - FingerTreeNode<a, m> init<a, m>(Measure<a, m>, FingerTreeNode<a, m>)
 - FingerTreeNode<a, m> deep<a, m>(Measure<a, m>, FSharpOption<Affix<a>>, FingerTreeNode<Node<a, m>, m>, FSharpOption<Affix<a>>)
 - FingerTreeNode<a, m> concatWithMiddle<a, m>(Measure<a, m>, FingerTreeNode<a, m>, FSharpList<a>, FingerTreeNode<a, m>)

 Aardvark.Base.Arrays+Arr (Aardvark.Base.FSharp 5.3.0.0):
 - Arr<d, b> map<a, b, d>(FSharpFunc<a, b>, Arr<d, a>)
 - Arr<d, a> ofList<a, d>(FSharpList<a>)
 - Arr<d, a> ofSeq<a, d>(IEnumerable<a>)

 Aardvark.Base.Cancellable+Cancellable (Aardvark.Base.FSharp 5.3.0.0):
 - Cancellable<Unit> onCancel(FSharpFunc<Unit, Unit>)
 - Cancellable<Unit> ignore<a>(Cancellable<a>)
 - Cancellable<a> withCompensation<a>(FSharpFunc<a, Unit>, Cancellable<a>)
 - Cancellable<a> tryFinallyAndUndo<a>(FSharpFunc<Unit, Tuple<Unit, FSharpFunc<a, Unit>>>, Cancellable<a>)
 - Cancellable<a> tryFinally<a>(FSharpFunc<Unit, Unit>, Cancellable<a>)
 - Cancellable<CancellationToken> cancellationToken()

 Aardvark.Base.Cancellable+StatefulStepVar+Step (Aardvark.Base.FSharp 5.3.0.0):
 - Step<a, b> ofFun<a, b>(FSharpFunc<a, Cancellable<b>>)

 Aardvark.Base.Monads+Optics+Lens (Aardvark.Base.FSharp 5.3.0.0):
 - Lens<a, b> create<a, b>(FSharpFunc<a, b>, FSharpFunc<a, FSharpFunc<b, a>>)

 Aardvark.Base.Monads+Optics+Prism (Aardvark.Base.FSharp 5.3.0.0):
 - Prism<a, b> create<a, b>(FSharpFunc<a, FSharpOption<b>>, FSharpFunc<a, FSharpFunc<b, a>>)

 Aardvark.Base.Monads+State+State (Aardvark.Base.FSharp 5.3.0.0):
 - State<s, Unit> ignore<s, a>(State<s, a>)
 - State<s, b> map<a, b, s>(FSharpFunc<a, b>, State<s, a>)
 - State<s, b> bind<a, s, b>(FSharpFunc<a, State<s, b>>, State<s, a>)
 - State<s, a> value<a, s>(a)
 - State<s, s> get<s>()
 - State<s, Unit> put<s>(s)
 - State<s, Unit> modify<s>(FSharpFunc<s, s>)
 - State<s, a> custom<s, a>(FSharpFunc<s, Tuple<s, a>>)

 Aardvark.Base.Geometry.Spatial (Aardvark.Base.FSharp 5.3.0.0):
 - Spatial<Triangle3d> triangle { get; }
 - Spatial<Box3d> box { get; }
 - Spatial<V3d> point { get; }

 Aardvark.Base.IL.Serializer+RefMap (Aardvark.Base.FSharp 5.3.0.0):
 - RefMap<a, b> empty<a, b>()
 - RefMap<a, b> add<a, b>(a, b, RefMap<a, b>)
 - RefMap<a, b> remove<a, b>(a, RefMap<a, b>)
 - RefMap<a, b> update<a, b>(a, FSharpFunc<FSharpOption<b>, b>, RefMap<a, b>)

 Aardvark.Base.IL.Serializer+Coder (Aardvark.Base.FSharp 5.3.0.0):
 - Coder<b> map<a, b>(FSharpFunc<a, b>, Coder<a>)
 - Coder<Unit> put(CoderState)
 - Coder<Unit> modify(FSharpFunc<CoderState, CoderState>)
 - Coder<a> custom<a>(FSharpFunc<CoderState, Tuple<CoderState, a>>)
 - Coder<Tuple<bool, Guid>> tryStore<a>(a)
 - Coder<FSharpOption<a>> tryLoad<a>(Guid)
 - Coder<Tuple<bool, Guid>> tryStoreLocal<a>(a)
 - Coder<FSharpOption<a>> tryLoadLocal<a>(Guid)
 - Coder<Unit> storeValue<a>(Guid, a)
 - Coder<Unit> pushName(string)
 - Coder<CoderState> state { get; }
 - Coder<Unit> popName { get; }

 Aardvark.Base.IL.Frontend+ConcList (Aardvark.Base.FSharp 5.3.0.0):
 - ConcList<a> empty<a>()
 - ConcList<a> single<a>(a)
 - ConcList<a> ofList<a>(FSharpList<a>)
 - ConcList<a> ofSeq<a, a>(a)
 - ConcList<a> ofArray<a>(a[])
 - ConcList<a> append<a>(ConcList<a>, ConcList<a>)
 - ConcList<a> concat<a, a>(a)
 - ConcList<a> cons<a>(a, ConcList<a>)
 - ConcList<a> snoc<a>(ConcList<a>, a)

 Accord.Math.Sparse (Accord 3.8.0.0):
 - Sparse<double> Parse(string, Nullable<double>)
 - Sparse<double> Parse(string[], Nullable<double>)
 - Sparse<T> FromDense<T>(T[], bool)
 - Sparse<double> FromDictionary(IDictionary<int, int>)

 Accord.Statistics.Distributions.Sampling.MetropolisHasting (Accord.Statistics 3.8.0.0):
 - MetropolisHasting<double, Independent<NormalDistribution>, T> Continuous<T>(int, T)
 - MetropolisHasting<int, Independent<SymmetricGeometricDistribution, int>, T> Discrete<T>(int, T)

 Accord.Statistics.Distributions.Sampling.MetropolisHasting (Accord.Statistics 3.8.0.0):
 - MetropolisHasting<double, Independent<NormalDistribution>> Continuous(int, Func<double[], double>)
 - MetropolisHasting<int, Independent<SymmetricGeometricDistribution, int>> Discrete(int, Func<int[], double>)

 Accord.Statistics.Kernels.Gaussian (Accord.Statistics 3.8.0.0):
 - Gaussian<T> Estimate<T>(T, double[][])
 - Gaussian<T> Estimate<T>(T, double[][], out DoubleRange)
 - Gaussian<T> Estimate<T>(T, double[][], int)
 - Gaussian<T> Estimate<T>(T, double[][], int, out DoubleRange)

 Accord.Statistics.Models.Fields.HiddenConditionalRandomField (Accord.Statistics 3.8.0.0):
 - HiddenConditionalRandomField<int> FromHiddenMarkov(HiddenMarkovClassifier)
 - HiddenConditionalRandomField<int> FromHiddenMarkov(HiddenMarkovClassifier<GeneralDiscreteDistribution, int>)
 - HiddenConditionalRandomField<double> FromHiddenMarkov(HiddenMarkovClassifier<NormalDistribution, double>)
 - HiddenConditionalRandomField<double[]> FromHiddenMarkov(HiddenMarkovClassifier<Independent<NormalDistribution>, double[]>)
 - HiddenConditionalRandomField<double[]> FromHiddenMarkov(HiddenMarkovClassifier<Independent<NormalDistribution, double>, double[]>)
 - HiddenConditionalRandomField<double[]> FromHiddenMarkov(HiddenMarkovClassifier<MultivariateNormalDistribution, double[]>)

 Accord.Statistics.Models.Markov.HiddenMarkovClassifier (Accord.Statistics 3.8.0.0):
 - HiddenMarkovClassifier<GeneralDiscreteDistribution, int> CreateGeneric2(int, int[], int)

 Accord.Statistics.Models.Markov.HiddenMarkovModel (Accord.Statistics 3.8.0.0):
 - HiddenMarkovModel<GeneralDiscreteDistribution, int> CreateDiscrete(double[], double[], double[], bool)
 - HiddenMarkovModel<GeneralDiscreteDistribution, int> CreateDiscrete(ITopology, int)
 - HiddenMarkovModel<GeneralDiscreteDistribution, int> CreateDiscrete(ITopology, int, bool)
 - HiddenMarkovModel<GeneralDiscreteDistribution, int> CreateDiscrete(int, int)
 - HiddenMarkovModel<GeneralDiscreteDistribution, int> CreateDiscrete(int, int, bool)

 Accord.Statistics.Models.Markov.HiddenMarkovModel (Accord.Statistics 3.8.0.0):
 - HiddenMarkovModel<GeneralDiscreteDistribution> CreateGeneric(double[], double[], double[], bool)
 - HiddenMarkovModel<GeneralDiscreteDistribution> CreateGeneric(ITopology, int)
 - HiddenMarkovModel<GeneralDiscreteDistribution> CreateGeneric(ITopology, int, bool)
 - HiddenMarkovModel<GeneralDiscreteDistribution> CreateGeneric(int, int)
 - HiddenMarkovModel<GeneralDiscreteDistribution> CreateGeneric(int, int, bool)
 - HiddenMarkovModel<TDistribution> Load<TDistribution>(Stream)
 - HiddenMarkovModel<TDistribution> Load<TDistribution>(string)

 Accord.Statistics.Models.Markov.HiddenMarkovClassifier (Accord.Statistics 3.8.0.0):
 - HiddenMarkovClassifier<GeneralDiscreteDistribution> CreateGeneric(int, int[], int)
 - HiddenMarkovClassifier<TDistribution> Load<TDistribution>(Stream)
 - HiddenMarkovClassifier<TDistribution> Load<TDistribution>(string)

 Accord.Statistics.Models.Markov.Learning.BaumWelchLearning (Accord.Statistics 3.8.0.0):
 - BaumWelchLearning<Mixture<NormalDistribution>> FromMixtureModel(HiddenMarkovModel<Mixture<NormalDistribution>>, NormalOptions)
 - BaumWelchLearning<MultivariateMixture<MultivariateNormalDistribution>> FromMixtureModel(HiddenMarkovModel<MultivariateMixture<MultivariateNormalDistribution>>, NormalOptions)

 Akka.Routing.ConsistentHash (Akka 1.5.44.0):
 - ConsistentHash<T> Create<T>(IEnumerable<T>, int)

 Akka.Streams.Inlet (Akka.Streams 1.5.44.0):
 - Inlet<T> Create<T>(Inlet)

 Akka.Streams.Outlet (Akka.Streams 1.5.44.0):
 - Outlet<T> Create<T>(Outlet)

 Akka.Streams.BidiShape (Akka.Streams 1.5.44.0):
 - BidiShape<TIn1, TOut1, TIn2, TOut2> FromFlows<TIn1, TOut1, TIn2, TOut2>(FlowShape<TIn1, TOut1>, FlowShape<TIn2, TOut2>)

 Akka.Streams.Dsl.UnzipWith (Akka.Streams 1.5.44.0):
 - UnzipWith<TIn, TOut0, TOut1> Apply<TIn, TOut0, TOut1>(Func<TIn, ValueTuple<TOut0, TOut1>>, UnzipWithCreator<TIn, TOut0, TOut1>)

 Akka.Streams.Dsl.UnzipWith (Akka.Streams 1.5.44.0):
 - UnzipWith<TIn, TOut0, TOut1, TOut2> Apply<TIn, TOut0, TOut1, TOut2>(Func<TIn, ValueTuple<TOut0, TOut1, TOut2>>, UnzipWithCreator<TIn, TOut0, TOut1, TOut2>)

 Akka.Streams.Dsl.UnzipWith (Akka.Streams 1.5.44.0):
 - UnzipWith<TIn, TOut0, TOut1, TOut2, TOut3> Apply<TIn, TOut0, TOut1, TOut2, TOut3>(Func<TIn, ValueTuple<TOut0, TOut1, TOut2, TOut3>>, UnzipWithCreator<TIn, TOut0, TOut1, TOut2, TOut3>)

 Akka.Streams.Dsl.UnzipWith (Akka.Streams 1.5.44.0):
 - UnzipWith<TIn, TOut0, TOut1, TOut2, TOut3, TOut4> Apply<TIn, TOut0, TOut1, TOut2, TOut3, TOut4>(Func<TIn, ValueTuple<TOut0, TOut1, TOut2, TOut3, TOut4>>, UnzipWithCreator<TIn, TOut0, TOut1, TOut2, TOut3, TOut4>)

 Akka.Streams.Dsl.UnzipWith (Akka.Streams 1.5.44.0):
 - UnzipWith<TIn, TOut0, TOut1, TOut2, TOut3, TOut4, TOut5> Apply<TIn, TOut0, TOut1, TOut2, TOut3, TOut4, TOut5>(Func<TIn, ValueTuple<TOut0, TOut1, TOut2, TOut3, TOut4, TOut5>>, UnzipWithCreator<TIn, TOut0, TOut1, TOut2, TOut3, TOut4, TOut5>)

 Akka.Streams.Dsl.UnzipWith (Akka.Streams 1.5.44.0):
 - UnzipWith<TIn, TOut0, TOut1, TOut2, TOut3, TOut4, TOut5, TOut6> Apply<TIn, TOut0, TOut1, TOut2, TOut3, TOut4, TOut5, TOut6>(Func<TIn, ValueTuple<TOut0, TOut1, TOut2, TOut3, TOut4, TOut5, TOut6>>, UnzipWithCreator<TIn, TOut0, TOut1, TOut2, TOut3, TOut4, TOut5, TOut6>)

 Akka.Streams.Dsl.ZipWith (Akka.Streams 1.5.44.0):
 - ZipWith<TIn0, TIn1, TOut> Apply<TIn0, TIn1, TOut>(Func<TIn0, TIn1, TOut>)

 Akka.Streams.Dsl.ZipWith (Akka.Streams 1.5.44.0):
 - ZipWith<TIn0, TIn1, TIn2, TOut> Apply<TIn0, TIn1, TIn2, TOut>(Func<TIn0, TIn1, TIn2, TOut>)

 Akka.Streams.Dsl.ZipWith (Akka.Streams 1.5.44.0):
 - ZipWith<TIn0, TIn1, TIn2, TIn3, TOut> Apply<TIn0, TIn1, TIn2, TIn3, TOut>(Func<TIn0, TIn1, TIn2, TIn3, TOut>)

 Akka.Streams.Dsl.ZipWith (Akka.Streams 1.5.44.0):
 - ZipWith<TIn0, TIn1, TIn2, TIn3, TIn4, TOut> Apply<TIn0, TIn1, TIn2, TIn3, TIn4, TOut>(Func<TIn0, TIn1, TIn2, TIn3, TIn4, TOut>)

 Akka.Streams.Dsl.ZipWith (Akka.Streams 1.5.44.0):
 - ZipWith<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TOut> Apply<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TOut>(Func<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TOut>)

 Akka.Streams.Dsl.ZipWith (Akka.Streams 1.5.44.0):
 - ZipWith<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TOut> Apply<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TOut>(Func<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TOut>)

 Akka.Streams.Dsl.ZipWith (Akka.Streams 1.5.44.0):
 - ZipWith<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TIn7, TOut> Apply<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TIn7, TOut>(Func<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TIn7, TOut>)

 Akka.Streams.Dsl.ZipWith (Akka.Streams 1.5.44.0):
 - ZipWith<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TIn7, TIn8, TOut> Apply<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TIn7, TIn8, TOut>(Func<TIn0, TIn1, TIn2, TIn3, TIn4, TIn5, TIn6, TIn7, TIn8, TOut>)

 Akka.Streams.Dsl.BidiFlow (Akka.Streams 1.5.44.0):
 - BidiFlow<TIn1, TOut1, TIn2, TOut2, TMat> FromGraph<TIn1, TOut1, TIn2, TOut2, TMat>(IGraph<BidiShape<TIn1, TOut1, TIn2, TOut2>, TMat>)
 - BidiFlow<TIn1, TOut1, TIn2, TOut2, TMat> FromFlowsMat<TIn1, TOut1, TIn2, TOut2, TMat1, TMat2, TMat>(IGraph<FlowShape<TIn1, TOut1>, TMat1>, IGraph<FlowShape<TIn2, TOut2>, TMat2>, Func<TMat1, TMat2, TMat>)
 - BidiFlow<TIn1, TOut1, TIn2, TOut2, NotUsed> FromFlows<TIn1, TOut1, TIn2, TOut2, TMat1, TMat2>(IGraph<FlowShape<TIn1, TOut1>, TMat1>, IGraph<FlowShape<TIn2, TOut2>, TMat2>)
 - BidiFlow<TIn1, TOut1, TIn2, TOut2, NotUsed> FromFunction<TIn1, TOut1, TIn2, TOut2>(Func<TIn1, TOut1>, Func<TIn2, TOut2>)
 - BidiFlow<TIn, TIn, TOut, TOut, NotUsed> BidirectionalIdleTimeout<TIn, TOut>(TimeSpan)

 Akka.Streams.Dsl.Flow (Akka.Streams 1.5.44.0):
 - Flow<T, T, NotUsed> Identity<T>()
 - Flow<T, T, TMat> Identity<T, TMat>()
 - Flow<T, T, NotUsed> Create<T>()
 - Flow<T, T, TMat> Create<T, TMat>()
 - Flow<TIn, TOut, NotUsed> FromFunction<TIn, TOut>(Func<TIn, TOut>)
 - Flow<TIn, TOut, TMat> FromGraph<TIn, TOut, TMat>(IGraph<FlowShape<TIn, TOut>, TMat>)
 - Flow<TIn, TOut, Task<TMat>> Setup<TIn, TOut, TMat>(Func<ActorMaterializer, Attributes, Flow<TIn, TOut, TMat>>)
 - Flow<TIn, TOut, NotUsed> FromSinkAndSource<TIn, TOut, TMat>(IGraph<SinkShape<TIn>, TMat>, IGraph<SourceShape<TOut>, TMat>)
 - Flow<TIn, TOut, TMat> FromSinkAndSource<TIn, TOut, TMat1, TMat2, TMat>(IGraph<SinkShape<TIn>, TMat1>, IGraph<SourceShape<TOut>, TMat2>, Func<TMat1, TMat2, TMat>)
 - Flow<TIn, TOut, Task<Option<TMat>>> LazyInitAsync<TIn, TOut, TMat>(Func<Task<Flow<TIn, TOut, TMat>>>)

 Akka.Streams.Dsl.FlowWithContext (Akka.Streams 1.5.44.0):
 - FlowWithContext<TIn, TCtx, TIn, TCtx, NotUsed> Create<TIn, TCtx>()
 - FlowWithContext<TIn, TCtxIn, TOut, TCtxOut, TMat> From<TIn, TCtxIn, TOut, TCtxOut, TMat>(Flow<ValueTuple<TIn, TCtxIn>, ValueTuple<TOut, TCtxOut>, TMat>)

 Akka.Streams.Dsl.WireTap (Akka.Streams 1.5.44.0):
 - WireTap<T> Create<T>()

 Akka.Streams.Dsl.RunnableGraph (Akka.Streams 1.5.44.0):
 - RunnableGraph<TMat> FromGraph<TMat>(IGraph<ClosedShape, TMat>)

 Akka.Streams.Dsl.Sink (Akka.Streams 1.5.44.0):
 - Sink<TIn, TMat> Wrap<TIn, TMat>(IGraph<SinkShape<TIn>, TMat>)
 - Sink<TIn, Task<TIn>> First<TIn>()
 - Sink<TIn, Task<TIn>> FirstOrDefault<TIn>()
 - Sink<TIn, Task<TIn>> Last<TIn>()
 - Sink<TIn, Task<TIn>> LastOrDefault<TIn>()
 - Sink<TIn, Task<IImmutableList<TIn>>> Seq<TIn>()
 - Sink<TIn, Task<Done>> Ignore<TIn>()
 - Sink<TIn, Task<Done>> ForEach<TIn>(Action<TIn>)
 - Sink<TIn, Task<Done>> ForEachAsync<TIn>(int, Func<TIn, Task>)
 - Sink<TIn, NotUsed> Combine<TIn, TOut, TMat>(Func<int, IGraph<UniformFanOutShape<TIn, TOut>, TMat>>, Sink<TOut, NotUsed>, Sink<TOut, NotUsed>, Sink<TOut, NotUsed>[])
 - Sink<TIn, Task<Done>> ForEachParallel<TIn>(int, Action<TIn>)
 - Sink<TIn, Task<TOut>> Aggregate<TIn, TOut>(TOut, Func<TOut, TIn, TOut>)
 - Sink<TIn, Task<TOut>> AggregateAsync<TIn, TOut>(TOut, Func<TOut, TIn, Task<TOut>>)
 - Sink<TIn, Task<TIn>> Sum<TIn>(Func<TIn, TIn, TIn>)
 - Sink<TIn, NotUsed> OnComplete<TIn>(Action, Action<Exception>)
 - Sink<TIn, NotUsed> ActorRef<TIn>(IActorRef, object, Func<Exception, object>)
 - Sink<TIn, NotUsed> ActorRef<TIn>(IActorRef, object)
 - Sink<TIn, NotUsed> ActorRefWithAck<TIn>(IActorRef, object, object, object, Func<Exception, object>)
 - Sink<TIn, IActorRef> ActorSubscriber<TIn>(Props)
 - Sink<TIn, ISinkQueue<TIn>> Queue<TIn>()
 - Sink<TIn, Task<TMat>> LazySink<TIn, TMat>(Func<TIn, Task<Sink<TIn, TMat>>>, Func<TMat>)
 - Sink<TIn, Task<Option<TMat>>> LazyInitAsync<TIn, TMat>(Func<Task<Sink<TIn, TMat>>>)
 - Sink<TIn, TMat> FromGraph<TIn, TMat>(IGraph<SinkShape<TIn>, TMat>)
 - Sink<TIn, NotUsed> Cancelled<TIn>()
 - Sink<T, IObservable<T>> AsObservable<T>()
 - Sink<T, ChannelReader<T>> ChannelReader<T>(int, bool, BoundedChannelFullMode)
 - Sink<T, NotUsed> FromWriter<T>(ChannelWriter<T>, bool)

 Akka.Streams.Dsl.Source (Akka.Streams 1.5.44.0):
 - Source<T, NotUsed> FromEnumerator<T>(Func<IEnumerator<T>>)
 - Source<T, NotUsed> Cycle<T>(Func<IEnumerator<T>>)
 - Source<T, NotUsed> From<T>(IEnumerable<T>)
 - Source<T, NotUsed> From<T>(Func<IAsyncEnumerable<T>>)
 - Source<T, NotUsed> Single<T>(T)
 - Source<T, TMat> FromGraph<T, TMat>(IGraph<SourceShape<T>, TMat>)
 - Source<T, Task<TMat>> Setup<T, TMat>(Func<ActorMaterializer, Attributes, Source<T, TMat>>)
 - Source<T, NotUsed> FromTask<T>(Task<T>)
 - Source<T, NotUsed> Never<T>()
 - Source<T, Task<M>> FromTaskSource<T, M>(Task<Source<T, M>>)
 - Source<T, ICancelable> Tick<T>(TimeSpan, TimeSpan, T)
 - Source<T, NotUsed> Repeat<T>(T)
 - Source<TElem, NotUsed> Unfold<TState, TElem>(TState, Func<TState, Option<ValueTuple<TState, TElem>>>)
 - Source<TElem, NotUsed> UnfoldAsync<TState, TElem>(TState, Func<TState, Task<Option<ValueTuple<TState, TElem>>>>)
 - Source<TElem, NotUsed> UnfoldInfinite<TState, TElem>(TState, Func<TState, ValueTuple<TState, TElem>>)
 - Source<T, NotUsed> Empty<T>()
 - Source<T, TaskCompletionSource<T>> Maybe<T>()
 - Source<T, NotUsed> Failed<T>(Exception)
 - Source<TOut, Task<TMat>> Lazily<TOut, TMat>(Func<Source<TOut, TMat>>)
 - Source<T, IActorRef> ActorPublisher<T>(Props)
 - Source<T, IActorRef> ActorRef<T>(int, OverflowStrategy)
 - Source<TOut2, NotUsed> Combine<T, TOut2>(Source<T, NotUsed>, Source<T, NotUsed>, Func<int, IGraph<UniformFanInShape<T, TOut2>, NotUsed>>, Source<T, NotUsed>[])
 - Source<TOut2, TMatOut> CombineMaterialized<T, TOut2, TMat1, TMat2, TMatOut>(Source<T, TMat1>, Source<T, TMat2>, Func<int, IGraph<UniformFanInShape<T, TOut2>, NotUsed>>, Func<TMat1, TMat2, TMatOut>)
 - Source<IImmutableList<T>, NotUsed> ZipN<T>(IEnumerable<Source<T, NotUsed>>)
 - Source<TOut2, NotUsed> ZipWithN<T, TOut2>(Func<IImmutableList<T>, TOut2>, IEnumerable<Source<T, NotUsed>>)
 - Source<T, ISourceQueueWithComplete<T>> Queue<T>(int, OverflowStrategy)
 - Source<T, NotUsed> UnfoldResource<T, TSource>(Func<TSource>, Func<TSource, Option<T>>, Action<TSource>)
 - Source<T, NotUsed> UnfoldResourceAsync<T, TSource>(Func<Task<TSource>>, Func<TSource, Task<Option<T>>>, Func<TSource, Task<Done>>)
 - Source<T, NotUsed> FromEvent<TDelegate, T>(Func<Action<T>, TDelegate>, Action<TDelegate>, Action<TDelegate>, int, OverflowStrategy)
 - Source<T, NotUsed> FromEvent<T>(Action<EventHandler<T>>, Action<EventHandler<T>>, int, OverflowStrategy)
 - Source<T, NotUsed> FromObservable<T>(IObservable<T>, int, OverflowStrategy)
 - Source<T, NotUsed> ChannelReader<T>(ChannelReader<T>)
 - Source<T, ChannelWriter<T>> Channel<T>(int, bool, BoundedChannelFullMode)

 Akka.Streams.Dsl.SourceWithContext (Akka.Streams 1.5.44.0):
 - SourceWithContext<TOut, TCtxOut, TMat> FromTuples<TOut, TCtxOut, TMat>(Source<ValueTuple<TOut, TCtxOut>, TMat>)

 Akka.Streams.Implementation.LazySource (Akka.Streams 1.5.44.0):
 - LazySource<TOut, TMat> Create<TOut, TMat>(Func<Source<TOut, TMat>>)

 Akka.Util.Result (Akka 1.5.44.0):
 - Result<T> Success<T>(T)
 - Result<T> Failure<T>(Exception)
 - Result<T> FromTask<T>(Task<T>)
 - Result<T> From<T>(Func<T>)

 Apprio.Enablement.Platform.Models.Result (Apprio.Enablement.Platform 15.18.1.0):
 - Result<T> FromValue<T>(T)
 - Result<T> FromValue<T>(T, Exception)

 Ardalis.Result.Result (Ardalis.Result 10.1.0.0):
 - Result<T> Success<T>(T)
 - Result<T> Success<T>(T, string)
 - Result<T> Created<T>(T)
 - Result<T> Created<T>(T, string)
 - Result<Result> Success(Result)
 - Result<Result> Success(Result, string)
 - Result<Result> Created(Result)
 - Result<Result> Created(Result, string)
 - Result<Result> Error(string)
 - Result<Result> Error(ErrorList)
 - Result<Result> Invalid(ValidationError)
 - Result<Result> Invalid(ValidationError[])
 - Result<Result> Invalid(IEnumerable<ValidationError>)
 - Result<Result> NotFound()
 - Result<Result> NotFound(string[])
 - Result<Result> Forbidden()
 - Result<Result> Forbidden(string[])
 - Result<Result> Unauthorized()
 - Result<Result> Unauthorized(string[])
 - Result<Result> Conflict()
 - Result<Result> Conflict(string[])
 - Result<Result> CriticalError(string[])
 - Result<Result> Unavailable(string[])
 - Result<Result> NoContent()

 Automatonymous.Behavior (Automatonymous 5.1.3.0):
 - Behavior<T> Empty<T>()
 - Behavior<T> Exception<T>()

 Automatonymous.Behavior (Automatonymous 5.1.3.0):
 - Behavior<T, TData> Empty<T, TData>()
 - Behavior<T, TData> Exception<T, TData>()

 Avalonia.Controls.ItemsSourceView (Avalonia.Controls 11.3.2.0):
 - ItemsSourceView<T> GetOrCreate<T>(IEnumerable)
 - ItemsSourceView<T> GetOrCreate<T>(IEnumerable<T>)

 Avalonia.Interactivity.RoutedEvent (Avalonia.Base 11.3.2.0):
 - RoutedEvent<TEventArgs> Register<TOwner, TEventArgs>(string, RoutingStrategies)
 - RoutedEvent<TEventArgs> Register<TEventArgs>(string, RoutingStrategies, Type)

 Avalonia.Utilities.WeakEvent (Avalonia.Base 11.3.2.0):
 - WeakEvent<TSender, TEventArgs> Register<TSender, TEventArgs>(Action<TSender, EventHandler<TEventArgs>>, Action<TSender, EventHandler<TEventArgs>>)
 - WeakEvent<TSender, TEventArgs> Register<TSender, TEventArgs>(Func<TSender, EventHandler<TEventArgs>, Action>)
 - WeakEvent<TSender, EventArgs> Register<TSender>(Action<TSender, EventHandler>, Action<TSender, EventHandler>)

 Azure.Operation (Azure.Core 1.46.2.0):
 - Operation<T> Rehydrate<T>(HttpPipeline, RehydrationToken, ClientOptions)

 Azure.Response (Azure.Core 1.46.2.0):
 - Response<T> FromValue<T>(T, Response)

 Azure.ResourceManager.ArmOperation (Azure.ResourceManager 1.13.1.0):
 - ArmOperation<T> Rehydrate<T>(ArmClient, RehydrationToken, ArmClientOptions)

 Azure.Search.Documents.Models.IndexDocumentsAction (Azure.Search.Documents 11.6.1.0):
 - IndexDocumentsAction<T> Upload<T>(T)
 - IndexDocumentsAction<T> Merge<T>(T)
 - IndexDocumentsAction<T> MergeOrUpload<T>(T)
 - IndexDocumentsAction<T> Delete<T>(T)
 - IndexDocumentsAction<SearchDocument> Delete(string, string)

 Azure.Search.Documents.Models.IndexDocumentsBatch (Azure.Search.Documents 11.6.1.0):
 - IndexDocumentsBatch<T> Upload<T>(IEnumerable<T>)
 - IndexDocumentsBatch<T> Merge<T>(IEnumerable<T>)
 - IndexDocumentsBatch<T> MergeOrUpload<T>(IEnumerable<T>)
 - IndexDocumentsBatch<T> Delete<T>(IEnumerable<T>)
 - IndexDocumentsBatch<SearchDocument> Delete(string, IEnumerable<string>)
 - IndexDocumentsBatch<T> Create<T>(IndexDocumentsAction<T>[])

 BenchmarkDotNet.Characteristics.Characteristic (BenchmarkDotNet 0.15.2.0):
 - Characteristic<T> Create<TOwner, T>(string)
 - Characteristic<T> Create<TOwner, T>(string, T)
 - Characteristic<T> Create<TOwner, T>(string, Func<CharacteristicObject, T, T>, T, bool)
 - Characteristic<T> CreateHidden<TOwner, T>(string)
 - Characteristic<T> CreateIgnoreOnApply<TOwner, T>(string)

 Blauhaus.Responses.Response (Blauhaus.Responses 1.0.0.0):
 - Response<T> Failure<T>(string)
 - Response<T> Failure<T>(Error)
 - Response<T> Failure<T>(IResponse)
 - Response<T> Success<T>(T)
 - Response<T> Success<T>(IResponse<T>)

 CacheManager.Core.Internal.UpdateItemResult (CacheManager.Core 2.0.0.0):
 - UpdateItemResult<TCacheValue> ForItemDidNotExist<TCacheValue>()
 - UpdateItemResult<TCacheValue> ForFactoryReturnedNull<TCacheValue>()
 - UpdateItemResult<TCacheValue> ForSuccess<TCacheValue>(CacheItem<TCacheValue>, bool, int)
 - UpdateItemResult<TCacheValue> ForTooManyRetries<TCacheValue>(int)

 Cassandra.UdtMap (Cassandra 3.99.0.0):
 - UdtMap<T> For<T>(string, string)

 Cassandra.Serialization.TypeSerializer (Cassandra 3.99.0.0):
 - readonly TypeSerializer<BigInteger> PrimitiveBigIntegerSerializer
 - readonly TypeSerializer<bool> PrimitiveBooleanSerializer
 - readonly TypeSerializer<byte[]> PrimitiveByteArraySerializer
 - readonly TypeSerializer<DateTimeOffset> PrimitiveDateTimeOffsetSerializer
 - readonly TypeSerializer<DateTime> PrimitiveDateTimeSerializer
 - readonly TypeSerializer<decimal> PrimitiveDecimalSerializer
 - readonly TypeSerializer<double> PrimitiveDoubleSerializer
 - readonly TypeSerializer<Duration> PrimitiveDurationSerializer
 - readonly TypeSerializer<float> PrimitiveFloatSerializer
 - readonly TypeSerializer<Guid> PrimitiveGuidSerializer
 - readonly TypeSerializer<int> PrimitiveIntSerializer
 - readonly TypeSerializer<IPAddress> PrimitiveIpAddressSerializer
 - readonly TypeSerializer<LocalDate> PrimitiveLocalDateSerializer
 - readonly TypeSerializer<LocalTime> PrimitiveLocalTimeSerializer
 - readonly TypeSerializer<long> PrimitiveLongSerializer
 - readonly TypeSerializer<sbyte> PrimitiveSbyteSerializer
 - readonly TypeSerializer<short> PrimitiveShortSerializer
 - readonly TypeSerializer<string> PrimitiveStringSerializer
 - readonly TypeSerializer<string> PrimitiveAsciiStringSerializer
 - readonly TypeSerializer<TimeUuid> PrimitiveTimeUuidSerializer

 Castle.Components.DictionaryAdapter.GenericDictionaryAdapter (Castle.Core 5.0.0.0):
 - GenericDictionaryAdapter<TValue> ForDictionaryAdapter<TValue>(IDictionary<string, TValue>)

 CSharpFunctionalExtensions.Maybe (CSharpFunctionalExtensions 3.6.0.0):
 - Maybe<T> From<T>(T)
 - Maybe<T> From<T>(Func<T>)

 CSharpFunctionalExtensions.Result (CSharpFunctionalExtensions 3.6.0.0):
 - Result<T> Failure<T>(string)
 - Result<T> FailureIf<T>(bool, T, string)
 - Result<T> FailureIf<T>(Func<bool>, ref T, string)
 - Result<T> Of<T>(T)
 - Result<T> Of<T>(Func<T>)
 - Result<T> Success<T>(T)
 - Result<T> SuccessIf<T>(bool, ref T, string)
 - Result<T> SuccessIf<T>(Func<bool>, ref T, string)
 - Result<T> Try<T>(Func<T>, Func<Exception, string>)

 CSharpFunctionalExtensions.Result (CSharpFunctionalExtensions 3.6.0.0):
 - Result<bool, E> Combine<T, E>(IEnumerable<Result<T, E>>, Func<IEnumerable<E>, E>)
 - Result<bool, E> Combine<T, E>(IEnumerable<Result<T, E>>)
 - Result<bool, E> Combine<T, E>(Result<T, E>[])
 - Result<bool, E> Combine<T, E>(Func<IEnumerable<E>, E>, Result<T, E>[])
 - Result<T, E> Failure<T, E>(E)
 - Result<T, E> FailureIf<T, E>(bool, ref T, ref E)
 - Result<T, E> FailureIf<T, E>(Func<bool>, ref T, ref E)
 - Result<T, E> Of<T, E>(T)
 - Result<T, E> Of<T, E>(Func<T>)
 - Result<T, E> Success<T, E>(T)
 - Result<T, E> SuccessIf<T, E>(bool, ref T, ref E)
 - Result<T, E> SuccessIf<T, E>(Func<bool>, ref T, ref E)
 - Result<T, E> Try<T, E>(Func<T>, Func<Exception, E>)

 CSharpFunctionalExtensions.UnitResult (CSharpFunctionalExtensions 3.6.0.0):
 - UnitResult<E> FailureIf<E>(bool, ref E)
 - UnitResult<E> FailureIf<E>(Func<bool>, ref E)
 - UnitResult<E> SuccessIf<E>(bool, ref E)
 - UnitResult<E> SuccessIf<E>(Func<bool>, ref E)
 - UnitResult<E> Failure<E>(ref E)
 - UnitResult<E> Success<E>()

 DevExpress.DataProcessing.DiTagLink (DevExpress.PivotGrid.v23.1.Core 23.1.5.0):
 - DiTagLink<N, E> New<N, E>(N, N, E)
 - DiTagLink<N, E> New<N, E>(STuple<N, N>, E)

 DevExpress.DataProcessing.Named (DevExpress.PivotGrid.v23.1.Core 23.1.5.0):
 - Named<T> New<T>(string, T)

 DevExpress.DataProcessing.NamedCollection (DevExpress.PivotGrid.v23.1.Core 23.1.5.0):
 - NamedCollection<T> New<T>(IEnumerable<Named<T>>)
 - NamedCollection<T> New<T>()

 DevExpress.DataProcessing.STuple (DevExpress.PivotGrid.v23.1.Core 23.1.5.0):
 - STuple<T1, T2> Create<T1, T2>(T1, T2)

 DevExpress.DataProcessing.InMemoryDataProcessor.DataVectorValue (DevExpress.PivotGrid.v23.1.Core 23.1.5.0):
 - DataVectorValue<T> Create<T>(T, SpecialDataValue)

 DevExpress.DataProcessing.InMemoryDataProcessor.ValueBox (DevExpress.PivotGrid.v23.1.Core 23.1.5.0):
 - ValueBox<T> New<T>(T)
 - ValueBox<T> NoValue<T>()

 DevExpress.Xpo.DB.OperationResult (DevExpress.Xpo.v24.2 24.2.8.0):
 - OperationResult<T> ExecuteClient<T, N>(OperationResultChannelPredicate<T>, Func<Exception, bool>, ref N)
 - OperationResult<T> ExecuteClient<T, N>(OperationResultChannelPredicate<T>, ref N)

 DevExpress.Xpo.DB.OperationResult (DevExpress.Xpo.v23.1 23.1.5.0):
 - OperationResult<T> ExecuteClient<T, N>(OperationResultChannelPredicate<T>, Func<Exception, bool>, ref N)
 - OperationResult<T> ExecuteClient<T, N>(OperationResultChannelPredicate<T>, ref N)

 DevExpress.XtraPivotGrid.Data.DataSourceWorkItem (DevExpress.PivotGrid.v23.1.Core 23.1.5.0):
 - DataSourceWorkItem<TResult> Create<T1, T2, T3, T4, T5, TResult>(PivotState, T1, T2, T3, T4, T5, Func<PivotState, T1, T2, T3, T4, T5, TResult>)
 - DataSourceWorkItem<TResult> Create<T1, T2, T3, T4, T5, TResult>(PivotState, T1, T2, T3, T4, T5, Func<T1, T2, T3, T4, T5, TResult>)
 - DataSourceWorkItem<TResult> Create<T1, T2, T3, T4, TResult>(PivotState, T1, T2, T3, T4, Func<PivotState, T1, T2, T3, T4, TResult>)
 - DataSourceWorkItem<TResult> Create<T1, T2, T3, T4, TResult>(PivotState, T1, T2, T3, T4, Func<T1, T2, T3, T4, TResult>)
 - DataSourceWorkItem<TResult> Create<T1, T2, T3, TResult>(PivotState, T1, T2, T3, Func<PivotState, T1, T2, T3, TResult>)
 - DataSourceWorkItem<TResult> Create<T1, T2, TResult>(bool, PivotState, T1, T2, Func<PivotState, T1, T2, TResult>)
 - DataSourceWorkItem<TResult> Create<T1, T2, T3, TResult>(PivotState, T1, T2, T3, Func<T1, T2, T3, TResult>)
 - DataSourceWorkItem<TResult> Create<T1, T2, TResult>(PivotState, T1, T2, Func<PivotState, T1, T2, TResult>)
 - DataSourceWorkItem<TResult> Create<T1, T2, TResult>(PivotState, T1, T2, Func<T1, T2, TResult>)
 - DataSourceWorkItem<object> Create<T1, T2>(PivotState, T1, T2, Action<T1, T2>)
 - DataSourceWorkItem<object> Create<T1, T2>(PivotState, T1, T2, Action<PivotState, T1, T2>)
 - DataSourceWorkItem<TResult> Create<T1, TResult>(PivotState, T1, Func<PivotState, T1, TResult>)
 - DataSourceWorkItem<TResult> Create<T1, TResult>(bool, PivotState, T1, Func<PivotState, T1, TResult>)
 - DataSourceWorkItem<TResult> Create<T1, TResult>(PivotState, T1, Func<T1, TResult>)
 - DataSourceWorkItem<object> Create<T1>(PivotState, T1, Action<T1>)
 - DataSourceWorkItem<TResult> Create<TResult>(PivotState, Func<PivotState, TResult>)
 - DataSourceWorkItem<TResult> Create<TResult>(bool, PivotState, Func<PivotState, TResult>)
 - DataSourceWorkItem<TResult> Create<TResult>(PivotState, Func<TResult>)
 - DataSourceWorkItem<object> Create(PivotState, Action)

 DevExpress.XtraReports.Parameters.Range (DevExpress.Data.v24.2 24.2.8.0):
 - Range<T> Create<T>(T, T)

 DevExpress.XtraReports.Parameters.Range (DevExpress.Data.v23.1 23.1.5.0):
 - Range<T> Create<T>(T, T)

 DevExpress.XtraReports.Web.Native.ClientControls.JsonHttpActionResult (DevExpress.XtraReports.v23.1.Web 23.1.5.0):
 - JsonHttpActionResult<T> Create<T>(T)
 - JsonHttpActionResult<T> CreateFromError<T>(string)
 - JsonHttpActionResult<object> CreateFromError(string)

 Discord.Optional (Discord.Net.Core 3.17.4.0):
 - Optional<T> Create<T>()
 - Optional<T> Create<T>(T)

 DotNetty.Transport.Channels.ChannelOption (DotNetty.Transport 0.7.6.0):
 - ChannelOption<T> ValueOf<T>(string)
 - ChannelOption<T> ValueOf<T>(Type, string)
 - ChannelOption<T> NewInstance<T>(string)
 - readonly ChannelOption<IByteBufferAllocator> Allocator
 - readonly ChannelOption<IRecvByteBufAllocator> RcvbufAllocator
 - readonly ChannelOption<IMessageSizeEstimator> MessageSizeEstimator
 - readonly ChannelOption<TimeSpan> ConnectTimeout
 - readonly ChannelOption<int> WriteSpinCount
 - readonly ChannelOption<int> WriteBufferHighWaterMark
 - readonly ChannelOption<int> WriteBufferLowWaterMark
 - readonly ChannelOption<bool> AllowHalfClosure
 - readonly ChannelOption<bool> AutoRead
 - readonly ChannelOption<bool> SoBroadcast
 - readonly ChannelOption<bool> SoKeepalive
 - readonly ChannelOption<int> SoSndbuf
 - readonly ChannelOption<int> SoRcvbuf
 - readonly ChannelOption<bool> SoReuseaddr
 - readonly ChannelOption<bool> SoReuseport
 - readonly ChannelOption<int> SoLinger
 - readonly ChannelOption<int> SoBacklog
 - readonly ChannelOption<int> SoTimeout
 - readonly ChannelOption<int> IpTos
 - readonly ChannelOption<EndPoint> IpMulticastAddr
 - readonly ChannelOption<NetworkInterface> IpMulticastIf
 - readonly ChannelOption<int> IpMulticastTtl
 - readonly ChannelOption<bool> IpMulticastLoopDisabled
 - readonly ChannelOption<bool> TcpNodelay

 DotNext.Optional (DotNext 5.23.0.0):
 - Optional<T> ToOptional<T>(ref Nullable<T>)
 - Optional<T> None<T>()
 - Optional<T> Some<T>(T)
 - Optional<T> Null<T>()
 - Optional<T> Flatten<T>(ref Optional<Optional<T>>)

 DotNext.Result (DotNext 5.23.0.0):
 - Result<T> FromValue<T>(T)
 - Result<T> FromException<T>(Exception)
 - Result<T> EnsureNotNull<T>(Result<T>)
 - Result<T> EnsureNotNull<T, TException>(Result<T>)

 DotNext.Runtime.BoxedValue (DotNext 5.23.0.0):
 - BoxedValue<T> Copy<T>(BoxedValue<T>)

 DryIoc.ServiceInfo+Typed (DryIoc 5.4.3.0):
 - Typed<TService> Of<TService>(IfUnresolved, object)

 DryIoc.FastExpressionCompiler.LightExpression.Expression (DryIoc 5.4.3.0):
 - Expression<TDelegate> Lambda<TDelegate>(Expression)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, Type)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression, Type)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression, ParameterExpression, Type)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression, ParameterExpression)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression, ParameterExpression, ParameterExpression, Type)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression, ParameterExpression, ParameterExpression)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression, ParameterExpression, ParameterExpression, ParameterExpression, Type)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression, ParameterExpression, ParameterExpression, ParameterExpression)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression, ParameterExpression, ParameterExpression, ParameterExpression, ParameterExpression, Type)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression, ParameterExpression, ParameterExpression, ParameterExpression, ParameterExpression)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression, ParameterExpression, ParameterExpression, ParameterExpression, ParameterExpression, ParameterExpression, Type)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression, ParameterExpression, ParameterExpression, ParameterExpression, ParameterExpression, ParameterExpression)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, IReadOnlyList<ParameterExpression>, Type)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>, Type)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, ParameterExpression[])
 - Expression<TDelegate> Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>)
 - Expression<TDelegate> Lambda<TDelegate>(Expression, string, ParameterExpression[])

 DryIoc.ImTools.St (DryIoc 5.4.3.0):
 - St<A> Of<A>(A)
 - St<A> Rent<A>(A)

 DryIoc.ImTools.St (DryIoc 5.4.3.0):
 - St<A, B> Of<A, B>(A, B)
 - St<A, B> Rent<A, B>(A, B)

 DryIoc.ImTools.Ref (DryIoc 5.4.3.0):
 - Ref<T> Of<T>(T)
 - Ref<T> NewRef<T>(Ref<T>)

 DryIoc.ImTools.KV (DryIoc 5.4.3.0):
 - KV<K, V> Of<K, V>(K, V)
 - KV<K, V> WithValue<K, V>(KV<K, V>, V)

 DryIoc.ImTools.ImList (DryIoc 5.4.3.0):
 - ImList<T> List<T>(T[])
 - ImList<T> ToImList<T>(IList<T>)
 - ImList<T> ToImList<T>(IEnumerable<T>)
 - ImList<T> List<T>(T)
 - ImList<T> List<T>(T, ImList<T>)
 - ImList<T> Reverse<T>(ImList<T>)
 - ImList<R> Map<T, R>(ImList<T>, Func<T, R>)
 - ImList<R> Map<T, R>(ImList<T>, Func<T, int, R>)

 DryIoc.ImTools.ImZipper (DryIoc 5.4.3.0):
 - ImZipper<T> Zip<T>(T[])
 - ImZipper<T> ShiftTo<T>(ImZipper<T>, int)
 - ImZipper<T> Update<T>(ImZipper<T>, Func<T, T>)
 - ImZipper<T> UpdateAt<T>(ImZipper<T>, int, Func<T, T>)
 - ImZipper<T> RemoveAt<T>(ImZipper<T>, int)

 DryIoc.ImTools.ImHashMap (DryIoc 5.4.3.0):
 - ImHashMap<K, V> AddOrGetEntry<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrUpdate<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> AddOrUpdateEntry<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrUpdate<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<K, V> AddOrUpdate<K, V>(ImHashMap<K, V>, int, K, V, Update<K, V>)
 - ImHashMap<K, V> AddOrUpdate<K, V>(ImHashMap<K, V>, K, V, Update<K, V>)
 - ImHashMap<K, V> Update<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> Update<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<K, V> UpdateToDefault<K, V>(ImHashMap<K, V>, int, K)
 - ImHashMap<K, V> UpdateToDefault<K, V>(ImHashMap<K, V>, K)
 - ImHashMap<K, V> Update<K, V>(ImHashMap<K, V>, int, K, V, Update<K, V>)
 - ImHashMap<K, V> Update<K, V>(ImHashMap<K, V>, K, V, Update<K, V>)
 - ImHashMap<K, V> AddOrKeepEntry<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrKeep<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> AddOrKeep<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<K, V> Remove<K, V>(ImHashMap<K, V>, int, K)
 - ImHashMap<K, V> Remove<K, V>(ImHashMap<K, V>, K)

 DryIoc.ImTools.ImMap (DryIoc 5.4.3.0):
 - ImMap<V> AddOrGetEntry<V>(ImMap<V>, ImMapEntry<V>)
 - ImMap<V> AddOrUpdateEntry<V>(ImMap<V>, ImMapEntry<V>)
 - ImMap<V> AddOrUpdate<V>(ImMap<V>, int, V)
 - ImMap<V> AddOrUpdate<V>(ImMap<V>, int, V, Update<int, V>)
 - ImMap<V> Update<V>(ImMap<V>, int, V)
 - ImMap<V> UpdateToDefault<V>(ImMap<V>, int)
 - ImMap<V> AddOrKeepEntry<V>(ImMap<V>, ImMapEntry<V>)
 - ImMap<V> AddOrKeep<V>(ImMap<V>, int, V)
 - ImMap<V> Remove<V>(ImMap<V>, int)

 DynamicData.Kernel.Optional (DynamicData 9.4.0.0):
 - Optional<T> None<T>()
 - Optional<T> Some<T>(T)

 EasyNetQ.Internals.DisposableAction (EasyNetQ 7.0.0.0):
 - DisposableAction<TState> Create<TState>(Action<TState>, TState)

 Elsa.Models.Result (Elsa.Abstractions 2.15.2.0):
 - Result<T> Success<T>(T)
 - Result<T> Failure<T>()

 Esprima.Ast.NodeList (Esprima 3.0.5.0):
 - NodeList<T> Create<T>(IEnumerable<T>)

 Fable.Core.Dart+DartNullable (Fable.Core 4.5.0.0):
 - DartNullable<T> ofOption<T>(FSharpOption<T>)
 - DartNullable<T> ofNullable<T>(Nullable<T>)

 Fake.Core.CreateProcess (Fake.Core.Process 6.1.3.0):
 - CreateProcess<ProcessResult<Unit>> fromCommand(Command)
 - CreateProcess<ProcessResult<Unit>> fromRawCommandLine(string, string)
 - CreateProcess<ProcessResult<Unit>> fromRawCommand(string, IEnumerable<string>)
 - CreateProcess<ProcessResult<Unit>> ofStartInfo(ProcessStartInfo)
 - CreateProcess<a> copyRedirectedProcessOutputsToStandardOutputs<a>(CreateProcess<a>)
 - CreateProcess<a> withWorkingDirectory<a>(string, CreateProcess<a>)
 - CreateProcess<a> disableTraceCommand<a>(CreateProcess<a>)
 - CreateProcess<a> withCommand<a>(Command, CreateProcess<a>)
 - CreateProcess<a> replaceFilePath<a>(string, CreateProcess<a>)
 - CreateProcess<a> mapFilePath<a>(FSharpFunc<string, string>, CreateProcess<a>)
 - CreateProcess<c> appendSimpleFuncs<a, b, c>(FSharpFunc<Unit, a>, FSharpFunc<a, FSharpFunc<Process, Unit>>, FSharpFunc<FSharpAsync<b>, FSharpFunc<a, FSharpFunc<Task<RawProcessResult>, FSharpAsync<c>>>>, FSharpFunc<a, Unit>, CreateProcess<b>)
 - CreateProcess<b> addOnSetup<a, b>(FSharpFunc<Unit, a>, CreateProcess<b>)
 - CreateProcess<a> addOnFinally<a>(FSharpFunc<Unit, Unit>, CreateProcess<a>)
 - CreateProcess<a> addOnStarted<a>(FSharpFunc<Unit, Unit>, CreateProcess<a>)
 - CreateProcess<a> addOnStartedEx<a>(FSharpFunc<StartedProcessInfo, Unit>, CreateProcess<a>)
 - CreateProcess<a> withEnvironment<a>(FSharpList<Tuple<string, string>>, CreateProcess<a>)
 - CreateProcess<a> withEnvironmentMap<a>(IImmutableDictionary<string, string>, CreateProcess<a>)
 - CreateProcess<a> setEnvironmentVariable<a>(string, string, CreateProcess<a>)
 - CreateProcess<a> withStandardOutput<a>(StreamSpecification, CreateProcess<a>)
 - CreateProcess<a> withStandardError<a>(StreamSpecification, CreateProcess<a>)
 - CreateProcess<a> withStandardInput<a>(StreamSpecification, CreateProcess<a>)
 - CreateProcess<b> map<a, b>(FSharpFunc<a, b>, CreateProcess<a>)
 - CreateProcess<ProcessResult<b>> mapResult<a, b>(FSharpFunc<a, b>, CreateProcess<ProcessResult<a>>)
 - CreateProcess<ProcessResult<ProcessOutput>> redirectOutput<a>(CreateProcess<a>)
 - CreateProcess<a> redirectOutputIfNotRedirected<a>(CreateProcess<a>)
 - CreateProcess<a> withOutputEvents<a>(FSharpFunc<string, Unit>, FSharpFunc<string, Unit>, CreateProcess<a>)
 - CreateProcess<a> withOutputEventsNotNull<a>(FSharpFunc<string, Unit>, FSharpFunc<string, Unit>, CreateProcess<a>)
 - CreateProcess<b> addOnExited<a, b>(FSharpFunc<a, FSharpFunc<int, b>>, CreateProcess<a>)
 - CreateProcess<a> ensureExitCodeWithMessage<a>(string, CreateProcess<a>)
 - CreateProcess<a> ensureExitCode<a>(CreateProcess<a>)
 - CreateProcess<a> warnOnExitCode<a>(string, CreateProcess<a>)
 - CreateProcess<a> withTimeout<a>(TimeSpan, CreateProcess<a>)

 FastExpressionCompiler.ImTools.RefEq (FastExpressionCompiler 5.3.0.0):
 - readonly RefEq<object> OfObject

 FileHelpers.MasterDetail.MasterDetails (FileHelpers 3.5.2.0):
 - MasterDetails<object, object> Empty { get; }

 FluentResults.Result (FluentResults 4.0.0.0):
 - Result<TValue> Ok<TValue>(TValue)
 - Result<TValue> Fail<TValue>(IError)
 - Result<TValue> Fail<TValue>(string)
 - Result<TValue> Fail<TValue>(IEnumerable<string>)
 - Result<TValue> Fail<TValue>(IEnumerable<IError>)
 - Result<IEnumerable<TValue>> Merge<TValue>(Result<TValue>[])
 - Result<IEnumerable<TValue>> MergeFlat<TValue, TArray>(Result<TArray>[])
 - Result<T> Try<T>(Func<T>, Func<Exception, IError>)
 - Result<T> Try<T>(Func<Result<T>>, Func<Exception, IError>)

 Foundation.NSDictionary (Microsoft.iOS 17.2.0.0):
 - NSDictionary<NSString, NSObject> FromUrl(NSUrl, out NSError)

 Foundation.NSDictionary (Microsoft.MacCatalyst 17.2.0.0):
 - NSDictionary<NSString, NSObject> FromUrl(NSUrl, out NSError)

 FreeSql.Internal.Model.CsToDb (FreeSql 3.5.209.0):
 - CsToDb<T> New<T>(T, string, string, Nullable<bool>, Nullable<bool>, object)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2> Create<T1, T2>(T1, T2)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3> Create<T1, T2, T3>(T1, T2, T3)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1, T2, T3, T4)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1, T2, T3, T4, T5)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1, T2, T3, T4, T5, T6)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1, T2, T3, T4, T5, T6, T7)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4, T5, T6, T7, T8> Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1, T2, T3, T4, T5, T6, T7, T8)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9>(T1, T2, T3, T4, T5, T6, T7, T8, T9)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

 FreeSql.Internal.Model.NativeTuple (FreeSql 3.5.209.0):
 - NativeTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Create<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

 FSharp.Control.AsyncSeqSrc (FSharp.Control.AsyncSeq 3.2.1.0):
 - AsyncSeqSrc<T> create<T>()

 Google.Protobuf.ExtensionSet (Google.Protobuf 3.31.1.0):
 - ExtensionSet<TTarget> Clone<TTarget>(ExtensionSet<TTarget>)

 Google.Protobuf.FieldCodec (Google.Protobuf 3.31.1.0):
 - FieldCodec<string> ForString(uint)
 - FieldCodec<ByteString> ForBytes(uint)
 - FieldCodec<bool> ForBool(uint)
 - FieldCodec<int> ForInt32(uint)
 - FieldCodec<int> ForSInt32(uint)
 - FieldCodec<uint> ForFixed32(uint)
 - FieldCodec<int> ForSFixed32(uint)
 - FieldCodec<uint> ForUInt32(uint)
 - FieldCodec<long> ForInt64(uint)
 - FieldCodec<long> ForSInt64(uint)
 - FieldCodec<ulong> ForFixed64(uint)
 - FieldCodec<long> ForSFixed64(uint)
 - FieldCodec<ulong> ForUInt64(uint)
 - FieldCodec<float> ForFloat(uint)
 - FieldCodec<double> ForDouble(uint)
 - FieldCodec<T> ForEnum<T>(uint, Func<T, int>, Func<int, T>)
 - FieldCodec<string> ForString(uint, string)
 - FieldCodec<ByteString> ForBytes(uint, ByteString)
 - FieldCodec<bool> ForBool(uint, bool)
 - FieldCodec<int> ForInt32(uint, int)
 - FieldCodec<int> ForSInt32(uint, int)
 - FieldCodec<uint> ForFixed32(uint, uint)
 - FieldCodec<int> ForSFixed32(uint, int)
 - FieldCodec<uint> ForUInt32(uint, uint)
 - FieldCodec<long> ForInt64(uint, long)
 - FieldCodec<long> ForSInt64(uint, long)
 - FieldCodec<ulong> ForFixed64(uint, ulong)
 - FieldCodec<long> ForSFixed64(uint, long)
 - FieldCodec<ulong> ForUInt64(uint, ulong)
 - FieldCodec<float> ForFloat(uint, float)
 - FieldCodec<double> ForDouble(uint, double)
 - FieldCodec<T> ForEnum<T>(uint, Func<T, int>, Func<int, T>, T)
 - FieldCodec<T> ForMessage<T>(uint, MessageParser<T>)
 - FieldCodec<T> ForGroup<T>(uint, uint, MessageParser<T>)
 - FieldCodec<T> ForClassWrapper<T>(uint)
 - FieldCodec<Nullable<T>> ForStructWrapper<T>(uint)

 GraphQL.Builders.ConnectionBuilder (GraphQL 8.5.0.0):
 - ConnectionBuilder<TSourceType> Create<TNodeType, TSourceType>()
 - ConnectionBuilder<TSourceType> Create<TNodeType, TSourceType>(string)
 - ConnectionBuilder<TSourceType> Create<TNodeType, TEdgeType, TSourceType>()
 - ConnectionBuilder<TSourceType> Create<TNodeType, TEdgeType, TSourceType>(string)
 - ConnectionBuilder<TSourceType> Create<TNodeType, TEdgeType, TConnectionType, TSourceType>()
 - ConnectionBuilder<TSourceType> Create<TNodeType, TEdgeType, TConnectionType, TSourceType>(string)

 Hl7.Fhir.Utility.Result (Hl7.Fhir.Support 4.3.0.0):
 - Result<TB> Select<TA, TB>(Result<TA>, Func<TA, TB>)
 - Result<TC> SelectMany<TA, TB, TC>(Result<TA>, Func<TA, Result<TB>>, Func<TA, TB, TC>)

 HotChocolate.Data.Filters.FilterInputTypeDescriptor (HotChocolate.Data 15.1.7.0):
 - FilterInputTypeDescriptor<T> New<T>(IDescriptorContext, Type, string)
 - FilterInputTypeDescriptor<T> From<T>(IDescriptorContext, FilterInputTypeDefinition, string)
 - FilterInputTypeDescriptor<T> From<T>(FilterInputTypeDescriptor, string)

 HotChocolate.Data.Sorting.SortInputTypeDescriptor (HotChocolate.Data 15.1.7.0):
 - SortInputTypeDescriptor<T> New<T>(IDescriptorContext, Type, string)
 - SortInputTypeDescriptor<T> From<T>(IDescriptorContext, SortInputTypeDefinition, string)
 - SortInputTypeDescriptor<T> From<T>(SortInputTypeDescriptor, string)

 HotChocolate.Types.Descriptors.DirectiveTypeDescriptor (HotChocolate.Types 15.1.7.0):
 - DirectiveTypeDescriptor<T> New<T>(IDescriptorContext)

 HotChocolate.Types.Descriptors.EnumTypeDescriptor (HotChocolate.Types 15.1.7.0):
 - EnumTypeDescriptor<T> New<T>(IDescriptorContext)

 HotChocolate.Types.Descriptors.InputObjectTypeDescriptor (HotChocolate.Types 15.1.7.0):
 - InputObjectTypeDescriptor<T> New<T>(IDescriptorContext)
 - InputObjectTypeDescriptor<T> From<T>(IDescriptorContext, InputObjectTypeDefinition)

 HotChocolate.Types.Descriptors.InterfaceTypeDescriptor (HotChocolate.Types 15.1.7.0):
 - InterfaceTypeDescriptor<T> New<T>(IDescriptorContext)
 - InterfaceTypeDescriptor<T> From<T>(IDescriptorContext, InterfaceTypeDefinition)

 HotChocolate.Types.Descriptors.ObjectTypeDescriptor (HotChocolate.Types 15.1.7.0):
 - ObjectTypeDescriptor<T> New<T>(IDescriptorContext)
 - ObjectTypeDescriptor<T> From<T>(IDescriptorContext, ObjectTypeDefinition)

 HotChocolate.Types.Pagination.Connection (HotChocolate.Types.CursorPagination 15.1.7.0):
 - Connection<T> Empty<T>()

 ImageMagick.ExifTag (Magick.NET.Core 14.6.0.0):
 - ExifTag<byte> FaxProfile { get; }
 - ExifTag<byte> GPSAltitudeRef { get; }
 - ExifTag<byte> ModeNumber { get; }
 - ExifTag<byte[]> ClipPath { get; }
 - ExifTag<byte[]> CFAPattern2 { get; }
 - ExifTag<byte[]> GPSVersionID { get; }
 - ExifTag<byte[]> TIFFEPStandardID { get; }
 - ExifTag<byte[]> VersionYear { get; }
 - ExifTag<byte[]> XMP { get; }
 - ExifTag<byte[]> XPAuthor { get; }
 - ExifTag<byte[]> XPComment { get; }
 - ExifTag<byte[]> XPKeywords { get; }
 - ExifTag<byte[]> XPSubject { get; }
 - ExifTag<byte[]> XPTitle { get; }
 - ExifTag<double[]> IntergraphMatrix { get; }
 - ExifTag<double[]> ModelTiePoint { get; }
 - ExifTag<double[]> ModelTransform { get; }
 - ExifTag<double[]> PixelScale { get; }
 - ExifTag<uint> CodingMethods { get; }
 - ExifTag<uint> FaxRecvParams { get; }
 - ExifTag<uint> FaxRecvTime { get; }
 - ExifTag<uint> GPSIFDOffset { get; }
 - ExifTag<uint> ImageNumber { get; }
 - ExifTag<uint> ISOSpeed { get; }
 - ExifTag<uint> ISOSpeedLatitudeyyy { get; }
 - ExifTag<uint> ISOSpeedLatitudezzz { get; }
 - ExifTag<uint> JPEGInterchangeFormat { get; }
 - ExifTag<uint> JPEGInterchangeFormatLength { get; }
 - ExifTag<uint> MDFileTag { get; }
 - ExifTag<uint> ProfileType { get; }
 - ExifTag<uint> RecommendedExposureIndex { get; }
 - ExifTag<uint> StandardOutputSensitivity { get; }
 - ExifTag<uint> SubfileType { get; }
 - ExifTag<uint> SubIFDOffset { get; }
 - ExifTag<uint> T4Options { get; }
 - ExifTag<uint> T6Options { get; }
 - ExifTag<uint> T82ptions { get; }
 - ExifTag<uint> XClipPathUnits { get; }
 - ExifTag<uint> YClipPathUnits { get; }
 - ExifTag<uint[]> ColorResponseUnit { get; }
 - ExifTag<uint[]> FreeByteCounts { get; }
 - ExifTag<uint[]> FreeOffsets { get; }
 - ExifTag<uint[]> IntergraphRegisters { get; }
 - ExifTag<uint[]> JPEGACTables { get; }
 - ExifTag<uint[]> JPEGDCTables { get; }
 - ExifTag<uint[]> JPEGQTables { get; }
 - ExifTag<uint[]> SMaxSampleValue { get; }
 - ExifTag<uint[]> SMinSampleValue { get; }
 - ExifTag<uint[]> StripRowCounts { get; }
 - ExifTag<uint[]> TileOffsets { get; }
 - ExifTag<Number> BadFaxLines { get; }
 - ExifTag<Number> ConsecutiveBadFaxLines { get; }
 - ExifTag<Number> ImageLength { get; }
 - ExifTag<Number> ImageWidth { get; }
 - ExifTag<Number> PixelXDimension { get; }
 - ExifTag<Number> PixelYDimension { get; }
 - ExifTag<Number> RowsPerStrip { get; }
 - ExifTag<Number> StripByteCounts { get; }
 - ExifTag<Number> TileLength { get; }
 - ExifTag<Number> TileWidth { get; }
 - ExifTag<Number[]> ImageLayer { get; }
 - ExifTag<Number[]> StripOffsets { get; }
 - ExifTag<Number[]> TileByteCounts { get; }
 - ExifTag<Rational> Acceleration { get; }
 - ExifTag<Rational> ApertureValue { get; }
 - ExifTag<Rational> BatteryLevel { get; }
 - ExifTag<Rational> CompressedBitsPerPixel { get; }
 - ExifTag<Rational> DigitalZoomRatio { get; }
 - ExifTag<Rational> ExposureIndex { get; }
 - ExifTag<Rational> ExposureIndex2 { get; }
 - ExifTag<Rational> ExposureTime { get; }
 - ExifTag<Rational> FlashEnergy { get; }
 - ExifTag<Rational> FlashEnergy2 { get; }
 - ExifTag<Rational> FocalLength { get; }
 - ExifTag<Rational> FocalPlaneXResolution { get; }
 - ExifTag<Rational> FocalPlaneXResolution2 { get; }
 - ExifTag<Rational> FocalPlaneYResolution { get; }
 - ExifTag<Rational> FocalPlaneYResolution2 { get; }
 - ExifTag<Rational> FNumber { get; }
 - ExifTag<Rational> GPSAltitude { get; }
 - ExifTag<Rational> GPSDestBearing { get; }
 - ExifTag<Rational> GPSDestDistance { get; }
 - ExifTag<Rational> GPSImgDirection { get; }
 - ExifTag<Rational> GPSDOP { get; }
 - ExifTag<Rational> GPSSpeed { get; }
 - ExifTag<Rational> GPSTrack { get; }
 - ExifTag<Rational> Humidity { get; }
 - ExifTag<Rational> MaxApertureValue { get; }
 - ExifTag<Rational> MDScalePixel { get; }
 - ExifTag<Rational> Pressure { get; }
 - ExifTag<Rational> SubjectDistance { get; }
 - ExifTag<Rational> XPosition { get; }
 - ExifTag<Rational> XResolution { get; }
 - ExifTag<Rational> YPosition { get; }
 - ExifTag<Rational> YResolution { get; }
 - ExifTag<Rational[]> GPSDestLatitude { get; }
 - ExifTag<Rational[]> GPSDestLongitude { get; }
 - ExifTag<Rational[]> GPSLatitude { get; }
 - ExifTag<Rational[]> GPSLongitude { get; }
 - ExifTag<Rational[]> GPSTimestamp { get; }
 - ExifTag<Rational[]> LensInfo { get; }
 - ExifTag<Rational[]> PrimaryChromaticities { get; }
 - ExifTag<Rational[]> ReferenceBlackWhite { get; }
 - ExifTag<Rational[]> YCbCrCoefficients { get; }
 - ExifTag<Rational[]> WhitePoint { get; }
 - ExifTag<ushort> CellLength { get; }
 - ExifTag<ushort> CellWidth { get; }
 - ExifTag<ushort> CleanFaxData { get; }
 - ExifTag<ushort> ColorSpace { get; }
 - ExifTag<ushort> Compression { get; }
 - ExifTag<ushort> Contrast { get; }
 - ExifTag<ushort> CustomRendered { get; }
 - ExifTag<ushort> DotRange { get; }
 - ExifTag<ushort> ExposureMode { get; }
 - ExifTag<ushort> ExposureProgram { get; }
 - ExifTag<ushort> FillOrder { get; }
 - ExifTag<ushort> Flash { get; }
 - ExifTag<ushort> FocalLengthIn35mmFilm { get; }
 - ExifTag<ushort> FocalPlaneResolutionUnit { get; }
 - ExifTag<ushort> FocalPlaneResolutionUnit2 { get; }
 - ExifTag<ushort> GainControl { get; }
 - ExifTag<ushort> GPSDifferential { get; }
 - ExifTag<ushort> GrayResponseUnit { get; }
 - ExifTag<ushort> Indexed { get; }
 - ExifTag<ushort> Interlace { get; }
 - ExifTag<ushort> InkSet { get; }
 - ExifTag<ushort> JPEGProc { get; }
 - ExifTag<ushort> JPEGRestartInterval { get; }
 - ExifTag<ushort> LightSource { get; }
 - ExifTag<ushort> MeteringMode { get; }
 - ExifTag<ushort> NumberOfInks { get; }
 - ExifTag<ushort> OldSubfileType { get; }
 - ExifTag<ushort> OPIProxy { get; }
 - ExifTag<ushort> Orientation { get; }
 - ExifTag<ushort> PlanarConfiguration { get; }
 - ExifTag<ushort> PhotometricInterpretation { get; }
 - ExifTag<ushort> Rating { get; }
 - ExifTag<ushort> RatingPercent { get; }
 - ExifTag<ushort> ResolutionUnit { get; }
 - ExifTag<ushort> SamplesPerPixel { get; }
 - ExifTag<ushort> Saturation { get; }
 - ExifTag<ushort> SceneCaptureType { get; }
 - ExifTag<ushort> SelfTimerMode { get; }
 - ExifTag<ushort> SensitivityType { get; }
 - ExifTag<ushort> SensingMethod { get; }
 - ExifTag<ushort> SensingMethod2 { get; }
 - ExifTag<ushort> Sharpness { get; }
 - ExifTag<ushort> SubjectDistanceRange { get; }
 - ExifTag<ushort> Thresholding { get; }
 - ExifTag<ushort> WhiteBalance { get; }
 - ExifTag<ushort> YCbCrPositioning { get; }
 - ExifTag<ushort[]> BitsPerSample { get; }
 - ExifTag<ushort[]> CFARepeatPatternDim { get; }
 - ExifTag<ushort[]> ColorMap { get; }
 - ExifTag<ushort[]> DefaultImageColor { get; }
 - ExifTag<ushort[]> ExtraSamples { get; }
 - ExifTag<ushort[]> GrayResponseCurve { get; }
 - ExifTag<ushort[]> HalftoneHints { get; }
 - ExifTag<ushort[]> IntergraphPacketData { get; }
 - ExifTag<ushort[]> ISOSpeedRatings { get; }
 - ExifTag<ushort[]> JPEGLosslessPredictors { get; }
 - ExifTag<ushort[]> JPEGPointTransforms { get; }
 - ExifTag<ushort[]> MaxSampleValue { get; }
 - ExifTag<ushort[]> MinSampleValue { get; }
 - ExifTag<ushort[]> PageNumber { get; }
 - ExifTag<ushort[]> Predictor { get; }
 - ExifTag<ushort[]> SampleFormat { get; }
 - ExifTag<ushort[]> SubjectArea { get; }
 - ExifTag<ushort[]> SubjectLocation { get; }
 - ExifTag<ushort[]> TransferFunction { get; }
 - ExifTag<ushort[]> TransferRange { get; }
 - ExifTag<ushort[]> YCbCrSubsampling { get; }
 - ExifTag<SignedRational> AmbientTemperature { get; }
 - ExifTag<SignedRational> BrightnessValue { get; }
 - ExifTag<SignedRational> CameraElevationAngle { get; }
 - ExifTag<SignedRational> ExposureBiasValue { get; }
 - ExifTag<SignedRational> ShutterSpeedValue { get; }
 - ExifTag<SignedRational> WaterDepth { get; }
 - ExifTag<SignedRational[]> Decode { get; }
 - ExifTag<short[]> TimeZoneOffset { get; }
 - ExifTag<string> Artist { get; }
 - ExifTag<string> Copyright { get; }
 - ExifTag<string> DateTime { get; }
 - ExifTag<string> DateTimeDigitized { get; }
 - ExifTag<string> DateTimeOriginal { get; }
 - ExifTag<string> DocumentName { get; }
 - ExifTag<string> FaxSubaddress { get; }
 - ExifTag<string> GPSDateStamp { get; }
 - ExifTag<string> GPSDestBearingRef { get; }
 - ExifTag<string> GPSDestDistanceRef { get; }
 - ExifTag<string> GPSDestLatitudeRef { get; }
 - ExifTag<string> GPSDestLongitudeRef { get; }
 - ExifTag<string> GPSImgDirectionRef { get; }
 - ExifTag<string> GPSLatitudeRef { get; }
 - ExifTag<string> GPSLongitudeRef { get; }
 - ExifTag<string> GPSMapDatum { get; }
 - ExifTag<string> GPSMeasureMode { get; }
 - ExifTag<string> GDALMetadata { get; }
 - ExifTag<string> GDALNoData { get; }
 - ExifTag<string> GPSSatellites { get; }
 - ExifTag<string> GPSSpeedRef { get; }
 - ExifTag<string> GPSStatus { get; }
 - ExifTag<string> GPSTrackRef { get; }
 - ExifTag<string> HostComputer { get; }
 - ExifTag<string> ImageDescription { get; }
 - ExifTag<string> ImageID { get; }
 - ExifTag<string> ImageHistory { get; }
 - ExifTag<string> ImageUniqueID { get; }
 - ExifTag<string> InkNames { get; }
 - ExifTag<string> LensMake { get; }
 - ExifTag<string> LensModel { get; }
 - ExifTag<string> LensSerialNumber { get; }
 - ExifTag<string> Make { get; }
 - ExifTag<string> MDFileUnits { get; }
 - ExifTag<string> MDLabName { get; }
 - ExifTag<string> MDPrepDate { get; }
 - ExifTag<string> MDPrepTime { get; }
 - ExifTag<string> MDSampleInfo { get; }
 - ExifTag<string> Model { get; }
 - ExifTag<string> OffsetTime { get; }
 - ExifTag<string> OffsetTimeDigitized { get; }
 - ExifTag<string> OffsetTimeOriginal { get; }
 - ExifTag<string> OwnerName { get; }
 - ExifTag<string> PageName { get; }
 - ExifTag<string> RelatedSoundFile { get; }
 - ExifTag<string> SecurityClassification { get; }
 - ExifTag<string> SEMInfo { get; }
 - ExifTag<string> SpectralSensitivity { get; }
 - ExifTag<string> Software { get; }
 - ExifTag<string> SubsecTime { get; }
 - ExifTag<string> SubsecTimeDigitized { get; }
 - ExifTag<string> SubsecTimeOriginal { get; }
 - ExifTag<string> TargetPrinter { get; }
 - ExifTag<string> SerialNumber { get; }
 - ExifTag<byte[]> CFAPattern { get; }
 - ExifTag<byte[]> ComponentsConfiguration { get; }
 - ExifTag<byte[]> DeviceSettingDescription { get; }
 - ExifTag<byte[]> ExifVersion { get; }
 - ExifTag<byte> FileSource { get; }
 - ExifTag<byte[]> FlashpixVersion { get; }
 - ExifTag<byte[]> GPSProcessingMethod { get; }
 - ExifTag<byte[]> GPSAreaInformation { get; }
 - ExifTag<byte[]> ImageSourceData { get; }
 - ExifTag<byte[]> JPEGTables { get; }
 - ExifTag<byte[]> MakerNote { get; }
 - ExifTag<byte[]> Noise { get; }
 - ExifTag<byte[]> SpatialFrequencyResponse { get; }
 - ExifTag<byte[]> SpatialFrequencyResponse2 { get; }
 - ExifTag<byte[]> OECF { get; }
 - ExifTag<byte> SceneType { get; }
 - ExifTag<byte[]> UserComment { get; }

 ImTools.St (Baseline 4.1.0.0):
 - St<A> Of<A>(A)
 - St<A> Rent<A>(A)

 ImTools.St (Baseline 4.1.0.0):
 - St<A, B> Of<A, B>(A, B)
 - St<A, B> Rent<A, B>(A, B)

 ImTools.Ref (Baseline 4.1.0.0):
 - Ref<T> Of<T>(T)
 - Ref<T> NewRef<T>(Ref<T>)

 ImTools.KV (Baseline 4.1.0.0):
 - KV<K, V> Of<K, V>(K, V)
 - KV<K, V> WithValue<K, V>(KV<K, V>, V)

 ImTools.ImList (Baseline 4.1.0.0):
 - ImList<T> List<T>(T[])
 - ImList<T> ToImList<T>(IList<T>)
 - ImList<T> ToImList<T>(IEnumerable<T>)
 - ImList<T> List<T>(T)
 - ImList<T> List<T>(T, ImList<T>)
 - ImList<T> Reverse<T>(ImList<T>)
 - ImList<R> Map<T, R>(ImList<T>, Func<T, R>)
 - ImList<R> Map<T, R>(ImList<T>, Func<T, int, R>)

 ImTools.ImZipper (Baseline 4.1.0.0):
 - ImZipper<T> Zip<T>(T[])
 - ImZipper<T> ShiftTo<T>(ImZipper<T>, int)
 - ImZipper<T> Update<T>(ImZipper<T>, Func<T, T>)
 - ImZipper<T> UpdateAt<T>(ImZipper<T>, int, Func<T, T>)
 - ImZipper<T> RemoveAt<T>(ImZipper<T>, int)

 ImTools.ImHashMap (Baseline 4.1.0.0):
 - ImHashMap<K, V> BuildFromDifferent<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildFromDifferent<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildFromDifferent<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildUnchecked<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildFromDifferent<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildFromDifferent<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildFromDifferent<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildUnchecked<K, V, E>(E)
 - ImHashMap<int, V> AddOrGetEntry<V>(ImHashMap<int, V>, ImHashMapEntry<int, V>)
 - ImHashMap<K, V> AddOrGetEntry<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrGetEntryByReferenceEquals<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrUpdateEntry<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrUpdateEntryByReferenceEquals<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<int, V> AddOrUpdate<V>(ImHashMap<int, V>, int, V)
 - ImHashMap<int, V> AddSureNotPresent<V>(ImHashMap<int, V>, int, V)
 - ImHashMap<K, V> AddOrUpdate<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> AddOrUpdateByReferenceEquals<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> AddOrUpdate<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<K, V> AddOrUpdateByReferenceEquals<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<K, V> AddSureNotPresentEntry<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddSureNotPresent<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> AddSureNotPresent<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<int, V> AddOrUpdate<V>(ImHashMap<int, V>, int, V, Update<int, V>)
 - ImHashMap<K, V> AddOrUpdate<K, V>(ImHashMap<K, V>, int, K, V, Update<K, V>)
 - ImHashMap<K, V> AddOrUpdateByReferenceEquals<K, V>(ImHashMap<K, V>, int, K, V, Update<K, V>)
 - ImHashMap<K, V> AddOrUpdate<K, V>(ImHashMap<K, V>, K, V, Update<K, V>)
 - ImHashMap<int, V> AddOrKeep<V>(ImHashMap<int, V>, int, V)
 - ImHashMap<K, V> AddOrKeepEntry<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrKeepEntryByReferenceEquals<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrKeep<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> AddOrKeep<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<int, V> Update<V>(ImHashMap<int, V>, int, V)
 - ImHashMap<int, V> UpdateToDefault<V>(ImHashMap<int, V>, int)
 - ImHashMap<K, V> Update<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> Update<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<K, V> UpdateToDefault<K, V>(ImHashMap<K, V>, int, K)
 - ImHashMap<K, V> UpdateToDefault<K, V>(ImHashMap<K, V>, K)
 - ImHashMap<K, V> Update<K, V>(ImHashMap<K, V>, int, K, V, Update<K, V>)
 - ImHashMap<K, V> Update<K, V>(ImHashMap<K, V>, K, V, Update<K, V>)
 - ImHashMap<int, V> Remove<V>(ImHashMap<int, V>, int)
 - ImHashMap<K, V> Remove<K, V>(ImHashMap<K, V>, int, K)
 - ImHashMap<K, V> Remove<K, V>(ImHashMap<K, V>, K)

 JasperFx.Core.St (JasperFx.Core 0.0.0.0):
 - St<A> Of<A>(A)
 - St<A> Rent<A>(A)

 JasperFx.Core.St (JasperFx.Core 0.0.0.0):
 - St<A, B> Of<A, B>(A, B)
 - St<A, B> Rent<A, B>(A, B)

 JasperFx.Core.Ref (JasperFx.Core 0.0.0.0):
 - Ref<T> Of<T>(T)
 - Ref<T> NewRef<T>(Ref<T>)

 JasperFx.Core.KV (JasperFx.Core 0.0.0.0):
 - KV<K, V> Of<K, V>(K, V)
 - KV<K, V> WithValue<K, V>(KV<K, V>, V)

 JasperFx.Core.ImList (JasperFx.Core 0.0.0.0):
 - ImList<T> List<T>(T[])
 - ImList<T> ToImList<T>(IList<T>)
 - ImList<T> ToImList<T>(IEnumerable<T>)
 - ImList<T> List<T>(T)
 - ImList<T> List<T>(T, ImList<T>)
 - ImList<T> Reverse<T>(ImList<T>)
 - ImList<R> Map<T, R>(ImList<T>, Func<T, R>)
 - ImList<R> Map<T, R>(ImList<T>, Func<T, int, R>)

 JasperFx.Core.ImZipper (JasperFx.Core 0.0.0.0):
 - ImZipper<T> Zip<T>(T[])
 - ImZipper<T> ShiftTo<T>(ImZipper<T>, int)
 - ImZipper<T> Update<T>(ImZipper<T>, Func<T, T>)
 - ImZipper<T> UpdateAt<T>(ImZipper<T>, int, Func<T, T>)
 - ImZipper<T> RemoveAt<T>(ImZipper<T>, int)

 JasperFx.Core.ImHashMap (JasperFx.Core 0.0.0.0):
 - ImHashMap<K, V> BuildFromDifferent<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildFromDifferent<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildFromDifferent<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildUnchecked<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildFromDifferent<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildFromDifferent<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildFromDifferent<K, V>(ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> BuildUnchecked<K, V, E>(E)
 - ImHashMap<int, V> AddOrGetEntry<V>(ImHashMap<int, V>, ImHashMapEntry<int, V>)
 - ImHashMap<K, V> AddOrGetEntry<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrGetEntryByReferenceEquals<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrUpdateEntry<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrUpdateEntryByReferenceEquals<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<int, V> AddOrUpdate<V>(ImHashMap<int, V>, int, V)
 - ImHashMap<int, V> AddSureNotPresent<V>(ImHashMap<int, V>, int, V)
 - ImHashMap<K, V> AddOrUpdate<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> AddOrUpdateByReferenceEquals<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> AddOrUpdate<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<K, V> AddOrUpdateByReferenceEquals<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<K, V> AddSureNotPresentEntry<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddSureNotPresent<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> AddSureNotPresent<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<int, V> AddOrUpdate<V>(ImHashMap<int, V>, int, V, Update<int, V>)
 - ImHashMap<K, V> AddOrUpdate<K, V>(ImHashMap<K, V>, int, K, V, Update<K, V>)
 - ImHashMap<K, V> AddOrUpdateByReferenceEquals<K, V>(ImHashMap<K, V>, int, K, V, Update<K, V>)
 - ImHashMap<K, V> AddOrUpdate<K, V>(ImHashMap<K, V>, K, V, Update<K, V>)
 - ImHashMap<int, V> AddOrKeep<V>(ImHashMap<int, V>, int, V)
 - ImHashMap<K, V> AddOrKeepEntry<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrKeepEntryByReferenceEquals<K, V>(ImHashMap<K, V>, ImHashMapEntry<K, V>)
 - ImHashMap<K, V> AddOrKeep<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> AddOrKeep<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<int, V> Update<V>(ImHashMap<int, V>, int, V)
 - ImHashMap<int, V> UpdateToDefault<V>(ImHashMap<int, V>, int)
 - ImHashMap<K, V> Update<K, V>(ImHashMap<K, V>, int, K, V)
 - ImHashMap<K, V> Update<K, V>(ImHashMap<K, V>, K, V)
 - ImHashMap<K, V> UpdateToDefault<K, V>(ImHashMap<K, V>, int, K)
 - ImHashMap<K, V> UpdateToDefault<K, V>(ImHashMap<K, V>, K)
 - ImHashMap<K, V> Update<K, V>(ImHashMap<K, V>, int, K, V, Update<K, V>)
 - ImHashMap<K, V> Update<K, V>(ImHashMap<K, V>, K, V, Update<K, V>)
 - ImHashMap<int, V> Remove<V>(ImHashMap<int, V>, int)
 - ImHashMap<K, V> Remove<K, V>(ImHashMap<K, V>, int, K)
 - ImHashMap<K, V> Remove<K, V>(ImHashMap<K, V>, K)

 K4os.Compression.LZ4.Streams.Abstractions.ReadResult (K4os.Compression.LZ4.Streams 1.3.8.0):
 - ReadResult<TStreamState> Create<TStreamState>(TStreamState, int)

 Kusto.Cloud.Platform.Utils.DisposerSlim (Kusto.Cloud.Platform 13.0.2.0):
 - DisposerSlim<T1> Create<T1>(Action<T1>, T1)

 Kusto.Cloud.Platform.Utils.DisposerSlim (Kusto.Cloud.Platform 13.0.2.0):
 - DisposerSlim<T1, T2> Create<T1, T2>(Action<T1, T2>, T1, T2)

 Kusto.Cloud.Platform.Utils.ValueOrException (Kusto.Cloud.Platform 13.0.2.0):
 - ValueOrException<T> FromException<T>(Exception)
 - ValueOrException<T> FromValue<T>(T)

 LanguageExt.AtomHashMap (LanguageExt.Core 4.0.0.0):
 - AtomHashMap<K, V> ToAtom<K, V>(HashMap<K, V>)

 LanguageExt.AtomHashMap (LanguageExt.Core 4.0.0.0):
 - AtomHashMap<EqK, K, V> ToAtom<EqK, K, V>(HashMap<EqK, K, V>)

 LanguageExt.VectorClock (LanguageExt.Core 4.0.0.0):
 - VectorClock<A> Single<A>(A, long)
 - VectorClock<A> fromList<A>(Seq<ValueTuple<A, long>>)
 - VectorClock<A> combine<A>(Func<A, Option<long>, Option<long>, Option<long>>, VectorClock<A>, VectorClock<A>)
 - VectorClock<A> max<A>(VectorClock<A>, VectorClock<A>)

 LanguageExt.VectorClock (LanguageExt.Core 4.0.0.0):
 - VectorClock<OrdA, NumB, A, B> Single<OrdA, NumB, A, B>(A, B)
 - VectorClock<OrdA, NumB, A, B> fromList<OrdA, NumB, A, B>(Seq<ValueTuple<A, B>>)
 - VectorClock<OrdA, NumB, A, B> combine<OrdA, NumB, A, B>(Func<A, Option<B>, Option<B>, Option<B>>, VectorClock<OrdA, NumB, A, B>, VectorClock<OrdA, NumB, A, B>)
 - VectorClock<OrdA, NumB, A, B> max<OrdA, NumB, A, B>(VectorClock<OrdA, NumB, A, B>, VectorClock<OrdA, NumB, A, B>)

 LanguageExt.Version (LanguageExt.Core 4.0.0.0):
 - Version<Actor, K, V> ToVersion<ConflictV, OrdActor, Actor, K, V>(VersionVector<ConflictV, OrdActor, TLong, Actor, long, V>, K)

 LanguageExt.Compositions (LanguageExt.Core 4.0.0.0):
 - Compositions<A> skip<A>(int, Compositions<A>)
 - Compositions<A> take<MonoidA, A>(int, Compositions<A>)
 - Compositions<A> singleton<A>(A)
 - Compositions<A> cons<MonoidA, A>(A, Compositions<A>)
 - Compositions<A> fromList<MonoidA, A>(IEnumerable<A>)

 LanguageExt.Patch (LanguageExt.Core 4.0.0.0):
 - Patch<EqA, A> unsafeFromSeq<EqA, A>(Seq<Edit<EqA, A>>)
 - Patch<EqA, A> fromSeq<EqA, A>(Seq<Edit<EqA, A>>)
 - Patch<EqA, A> append<EqA, A>(Patch<EqA, A>, Patch<EqA, A>)
 - Patch<EqA, A> inverse<EqA, A>(Patch<EqA, A>)
 - Patch<EqA, A> empty<EqA, A>()
 - Patch<EqA, A> diff<EqA, A>(IEnumerable<A>, IEnumerable<A>)

 LanguageExt.Arr (LanguageExt.Core 4.0.0.0):
 - Arr<T> empty<T>()
 - Arr<T> create<T>()
 - Arr<T> create<T>(T[])
 - Arr<T> createRange<T>(IEnumerable<T>)
 - Arr<T> add<T>(Arr<T>, T)
 - Arr<T> addRange<T>(Arr<T>, IEnumerable<T>)
 - Arr<T> remove<T>(Arr<T>, T)
 - Arr<T> removeAt<T>(Arr<T>, int)
 - Arr<T> rev<T>(Arr<T>)
 - Arr<A> flatten<A>(Arr<Arr<A>>)

 LanguageExt.HashMap (LanguageExt.Core 4.0.0.0):
 - HashMap<K, V> clear<K, V>(HashMap<K, V>)
 - HashMap<K, V> empty<K, V>()
 - HashMap<K, V> create<K, V>()
 - HashMap<K, V> create<K, V>(Tuple<K, V>, Tuple<K, V>[])
 - HashMap<K, V> create<K, V>(ValueTuple<K, V>, ValueTuple<K, V>[])
 - HashMap<K, V> create<K, V>(KeyValuePair<K, V>, KeyValuePair<K, V>[])
 - HashMap<K, V> createRange<K, V>(IEnumerable<Tuple<K, V>>)
 - HashMap<K, V> createRange<K, V>(IEnumerable<ValueTuple<K, V>>)
 - HashMap<K, V> createRange<K, V>(IEnumerable<KeyValuePair<K, V>>)
 - HashMap<K, V> add<K, V>(HashMap<K, V>, K, V)
 - HashMap<K, V> tryAdd<K, V>(HashMap<K, V>, K, V)
 - HashMap<K, V> addOrUpdate<K, V>(HashMap<K, V>, K, V)
 - HashMap<K, V> addOrUpdate<K, V>(HashMap<K, V>, K, Func<V, V>, Func<V>)
 - HashMap<K, V> addOrUpdate<K, V>(HashMap<K, V>, K, Func<V, V>, V)
 - HashMap<K, V> addRange<K, V>(HashMap<K, V>, IEnumerable<Tuple<K, V>>)
 - HashMap<K, V> addRange<K, V>(HashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
 - HashMap<K, V> addRange<K, V>(HashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - HashMap<K, V> tryAddRange<K, V>(HashMap<K, V>, IEnumerable<Tuple<K, V>>)
 - HashMap<K, V> tryAddRange<K, V>(HashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
 - HashMap<K, V> tryAddRange<K, V>(HashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - HashMap<K, V> addOrUpdateRange<K, V>(HashMap<K, V>, IEnumerable<Tuple<K, V>>)
 - HashMap<K, V> addOrUpdateRange<K, V>(HashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
 - HashMap<K, V> addOrUpdateRange<K, V>(HashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - HashMap<K, V> remove<K, V>(HashMap<K, V>, K)
 - HashMap<K, V> setItem<K, V>(HashMap<K, V>, K, V)
 - HashMap<K, V> trySetItem<K, V>(HashMap<K, V>, K, V)
 - HashMap<K, V> trySetItem<K, V>(HashMap<K, V>, K, Func<V, V>)
 - HashMap<K, V> setItems<K, V>(HashMap<K, V>, IEnumerable<Tuple<K, V>>)
 - HashMap<K, V> setItems<K, V>(HashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
 - HashMap<K, V> setItems<K, V>(HashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - HashMap<K, V> trySetItems<K, V>(HashMap<K, V>, IEnumerable<Tuple<K, V>>)
 - HashMap<K, V> trySetItems<K, V>(HashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
 - HashMap<K, V> trySetItems<K, V>(HashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - HashMap<K, V> trySetItems<K, V>(HashMap<K, V>, IEnumerable<K>, Func<V, V>)
 - HashMap<K, V> setItem<K, V>(HashMap<K, V>, K, Func<V, V>)
 - HashMap<K, U> map<K, T, U>(HashMap<K, T>, Func<T, U>)
 - HashMap<K, U> map<K, T, U>(HashMap<K, T>, Func<K, T, U>)
 - HashMap<K, V> filter<K, V>(HashMap<K, V>, Func<V, bool>)
 - HashMap<K, V> filter<K, V>(HashMap<K, V>, Func<K, V, bool>)

 LanguageExt.HashMap (LanguageExt.Core 4.0.0.0):
 - HashMap<EqK, K, V> clear<EqK, K, V>(HashMap<EqK, K, V>)
 - HashMap<EqK, K, V> empty<EqK, K, V>()
 - HashMap<EqK, K, V> create<EqK, K, V>()
 - HashMap<EqK, K, V> create<EqK, K, V>(Tuple<K, V>, Tuple<K, V>[])
 - HashMap<EqK, K, V> create<EqK, K, V>(ValueTuple<K, V>, ValueTuple<K, V>[])
 - HashMap<EqK, K, V> create<EqK, K, V>(KeyValuePair<K, V>, KeyValuePair<K, V>[])
 - HashMap<EqK, K, V> createRange<EqK, K, V>(IEnumerable<Tuple<K, V>>)
 - HashMap<EqK, K, V> createRange<EqK, K, V>(IEnumerable<ValueTuple<K, V>>)
 - HashMap<EqK, K, V> createRange<EqK, K, V>(IEnumerable<KeyValuePair<K, V>>)
 - HashMap<EqK, K, V> add<EqK, K, V>(HashMap<EqK, K, V>, K, V)
 - HashMap<EqK, K, V> tryAdd<EqK, K, V>(HashMap<EqK, K, V>, K, V)
 - HashMap<EqK, K, V> addOrUpdate<EqK, K, V>(HashMap<EqK, K, V>, K, V)
 - HashMap<EqK, K, V> addOrUpdate<EqK, K, V>(HashMap<EqK, K, V>, K, Func<V, V>, Func<V>)
 - HashMap<EqK, K, V> addOrUpdate<EqK, K, V>(HashMap<EqK, K, V>, K, Func<V, V>, V)
 - HashMap<EqK, K, V> addRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
 - HashMap<EqK, K, V> addRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - HashMap<EqK, K, V> addRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - HashMap<EqK, K, V> tryAddRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
 - HashMap<EqK, K, V> tryAddRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - HashMap<EqK, K, V> tryAddRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - HashMap<EqK, K, V> addOrUpdateRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
 - HashMap<EqK, K, V> addOrUpdateRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - HashMap<EqK, K, V> addOrUpdateRange<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - HashMap<EqK, K, V> remove<EqK, K, V>(HashMap<EqK, K, V>, K)
 - HashMap<EqK, K, V> setItem<EqK, K, V>(HashMap<EqK, K, V>, K, V)
 - HashMap<EqK, K, V> trySetItem<EqK, K, V>(HashMap<EqK, K, V>, K, V)
 - HashMap<EqK, K, V> trySetItem<EqK, K, V>(HashMap<EqK, K, V>, K, Func<V, V>)
 - HashMap<EqK, K, V> setItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
 - HashMap<EqK, K, V> setItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - HashMap<EqK, K, V> setItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - HashMap<EqK, K, V> trySetItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
 - HashMap<EqK, K, V> trySetItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - HashMap<EqK, K, V> trySetItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - HashMap<EqK, K, V> trySetItems<EqK, K, V>(HashMap<EqK, K, V>, IEnumerable<K>, Func<V, V>)
 - HashMap<EqK, K, V> setItem<EqK, K, V>(HashMap<EqK, K, V>, K, Func<V, V>)
 - HashMap<EqK, K, U> map<EqK, K, T, U>(HashMap<EqK, K, T>, Func<T, U>)
 - HashMap<EqK, K, U> map<EqK, K, T, U>(HashMap<EqK, K, T>, Func<K, T, U>)
 - HashMap<EqK, K, V> filter<EqK, K, V>(HashMap<EqK, K, V>, Func<V, bool>)
 - HashMap<EqK, K, V> filter<EqK, K, V>(HashMap<EqK, K, V>, Func<K, V, bool>)

 LanguageExt.HashSet (LanguageExt.Core 4.0.0.0):
 - HashSet<T> create<T>()
 - HashSet<T> createRange<T>(IEnumerable<T>)
 - HashSet<T> empty<T>()
 - HashSet<T> add<T>(HashSet<T>, T)
 - HashSet<T> tryAdd<T>(HashSet<T>, T)
 - HashSet<T> addOrUpdate<T>(HashSet<T>, T)
 - HashSet<T> subtract<T>(HashSet<T>, HashSet<T>)
 - HashSet<T> union<T>(HashSet<T>, HashSet<T>)
 - HashSet<T> filter<T>(HashSet<T>, Func<T, bool>)
 - HashSet<T> intersect<T>(HashSet<T>, IEnumerable<T>)
 - HashSet<T> except<T>(HashSet<T>, IEnumerable<T>)
 - HashSet<T> symmetricExcept<T>(HashSet<T>, IEnumerable<T>)
 - HashSet<R> map<T, R>(HashSet<T>, Func<T, R>)
 - HashSet<T> remove<T>(HashSet<T>, T)

 LanguageExt.HashSet (LanguageExt.Core 4.0.0.0):
 - HashSet<EqT, T> create<EqT, T>()
 - HashSet<EqT, T> createRange<EqT, T>(IEnumerable<T>)
 - HashSet<EqT, T> empty<EqT, T>()
 - HashSet<EqT, T> add<EqT, T>(HashSet<EqT, T>, T)
 - HashSet<EqT, T> tryAdd<EqT, T>(HashSet<EqT, T>, T)
 - HashSet<EqT, T> addOrUpdate<EqT, T>(HashSet<EqT, T>, T)
 - HashSet<EqT, T> subtract<EqT, T>(HashSet<EqT, T>, HashSet<EqT, T>)
 - HashSet<EqT, T> union<EqT, T>(HashSet<EqT, T>, HashSet<EqT, T>)
 - HashSet<EqT, T> filter<EqT, T>(HashSet<EqT, T>, Func<T, bool>)
 - HashSet<EqT, T> intersect<EqT, T>(HashSet<EqT, T>, HashSet<EqT, T>)
 - HashSet<EqT, T> except<EqT, T>(HashSet<EqT, T>, HashSet<EqT, T>)
 - HashSet<EqT, T> symmetricExcept<EqT, T>(HashSet<EqT, T>, HashSet<EqT, T>)
 - HashSet<EqR, R> map<EqT, EqR, T, R>(HashSet<EqT, T>, Func<T, R>)
 - HashSet<EqT, T> map<EqT, T>(HashSet<EqT, T>, Func<T, T>)
 - HashSet<EqT, T> remove<EqT, T>(HashSet<EqT, T>, T)

 LanguageExt.Map (LanguageExt.Core 4.0.0.0):
 - Map<K, V> clear<K, V>(Map<K, V>)
 - Map<K, V> empty<K, V>()
 - Map<K, V> create<K, V>()
 - Map<K, V> create<K, V>(Tuple<K, V>, Tuple<K, V>[])
 - Map<K, V> create<K, V>(KeyValuePair<K, V>, KeyValuePair<K, V>[])
 - Map<K, V> create<K, V>(ValueTuple<K, V>, ValueTuple<K, V>[])
 - Map<K, V> createRange<K, V>(IEnumerable<Tuple<K, V>>)
 - Map<K, V> createRange<K, V>(IEnumerable<ValueTuple<K, V>>)
 - Map<K, V> createRange<K, V>(IEnumerable<KeyValuePair<K, V>>)
 - Map<K, V> add<K, V>(Map<K, V>, K, V)
 - Map<K, V> tryAdd<K, V>(Map<K, V>, K, V)
 - Map<K, V> tryAdd<K, V>(Map<K, V>, K, V, Func<Map<K, V>, V, Map<K, V>>)
 - Map<K, V> addOrUpdate<K, V>(Map<K, V>, K, V)
 - Map<K, V> addOrUpdate<K, V>(Map<K, V>, K, Func<V, V>, Func<V>)
 - Map<K, V> addOrUpdate<K, V>(Map<K, V>, K, Func<V, V>, V)
 - Map<K, V> addRange<K, V>(Map<K, V>, IEnumerable<Tuple<K, V>>)
 - Map<K, V> addRange<K, V>(Map<K, V>, IEnumerable<ValueTuple<K, V>>)
 - Map<K, V> addRange<K, V>(Map<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - Map<K, V> tryAddRange<K, V>(Map<K, V>, IEnumerable<Tuple<K, V>>)
 - Map<K, V> tryAddRange<K, V>(Map<K, V>, IEnumerable<ValueTuple<K, V>>)
 - Map<K, V> tryAddRange<K, V>(Map<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - Map<K, V> addOrUpdateRange<K, V>(Map<K, V>, IEnumerable<Tuple<K, V>>)
 - Map<K, V> addOrUpdateRange<K, V>(Map<K, V>, IEnumerable<ValueTuple<K, V>>)
 - Map<K, V> addOrUpdateRange<K, V>(Map<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - Map<K, V> remove<K, V>(Map<K, V>, K)
 - Map<K, V> setItem<K, V>(Map<K, V>, K, V)
 - Map<K, V> trySetItem<K, V>(Map<K, V>, K, V)
 - Map<K, V> trySetItem<K, V>(Map<K, V>, K, Func<V, V>)
 - Map<K, V> trySetItem<K, V>(Map<K, V>, K, Func<V, V>, Func<Map<K, V>, Map<K, V>>)
 - Map<K, V> setItems<K, V>(Map<K, V>, IEnumerable<Tuple<K, V>>)
 - Map<K, V> setItems<K, V>(Map<K, V>, IEnumerable<ValueTuple<K, V>>)
 - Map<K, V> setItems<K, V>(Map<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - Map<K, V> trySetItems<K, V>(Map<K, V>, IEnumerable<Tuple<K, V>>)
 - Map<K, V> trySetItems<K, V>(Map<K, V>, IEnumerable<ValueTuple<K, V>>)
 - Map<K, V> trySetItems<K, V>(Map<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - Map<K, V> trySetItems<K, V>(Map<K, V>, IEnumerable<K>, Func<V, V>)
 - Map<K, V> setItem<K, V>(Map<K, V>, K, Func<V, V>)
 - Map<K, U> map<K, T, U>(Map<K, T>, Func<T, U>)
 - Map<K, U> map<K, T, U>(Map<K, T>, Func<K, T, U>)
 - Map<K, V> filter<K, V>(Map<K, V>, Func<V, bool>)
 - Map<K, V> filter<K, V>(Map<K, V>, Func<K, V, bool>)
 - Map<K, R> choose<K, T, R>(Map<K, T>, Func<T, Option<R>>)
 - Map<K, R> choose<K, T, R>(Map<K, T>, Func<K, T, Option<R>>)
 - Map<K, V> freeze<K, V>(IDictionary<K, V>)
 - Map<K, V> Freeze<K, V>(IDictionary<K, V>)
 - Map<K, V> union<K, V>(Map<K, V>, Map<K, V>, WhenMatched<K, V, V, V>)
 - Map<K, A> union<K, A, B>(Map<K, A>, Map<K, B>, WhenMissing<K, B, A>, WhenMatched<K, A, B, A>)
 - Map<K, B> union<K, A, B>(Map<K, A>, Map<K, B>, WhenMissing<K, A, B>, WhenMatched<K, A, B, B>)
 - Map<K, C> union<K, A, B, C>(Map<K, A>, Map<K, B>, WhenMissing<K, A, C>, WhenMissing<K, B, C>, WhenMatched<K, A, B, C>)
 - Map<K, R> intersect<K, A, B, R>(Map<K, A>, Map<K, B>, WhenMatched<K, A, B, R>)
 - Map<K, V> except<K, V>(Map<K, V>, Map<K, V>)
 - Map<K, V> symmetricExcept<K, V>(Map<K, V>, Map<K, V>)

 LanguageExt.Map (LanguageExt.Core 4.0.0.0):
 - Map<OrdK, K, V> clear<OrdK, K, V>(Map<OrdK, K, V>)
 - Map<OrdK, K, V> empty<OrdK, K, V>()
 - Map<OrdK, K, V> create<OrdK, K, V>()
 - Map<OrdK, K, V> create<OrdK, K, V>(Tuple<K, V>, Tuple<K, V>[])
 - Map<OrdK, K, V> create<OrdK, K, V>(KeyValuePair<K, V>, KeyValuePair<K, V>[])
 - Map<OrdK, K, V> create<OrdK, K, V>(ValueTuple<K, V>, ValueTuple<K, V>[])
 - Map<OrdK, K, V> createRange<OrdK, K, V>(IEnumerable<Tuple<K, V>>)
 - Map<OrdK, K, V> createRange<OrdK, K, V>(IEnumerable<ValueTuple<K, V>>)
 - Map<OrdK, K, V> createRange<OrdK, K, V>(IEnumerable<KeyValuePair<K, V>>)
 - Map<OrdK, K, V> add<OrdK, K, V>(Map<OrdK, K, V>, K, V)
 - Map<OrdK, K, V> tryAdd<OrdK, K, V>(Map<OrdK, K, V>, K, V)
 - Map<OrdK, K, V> tryAdd<OrdK, K, V>(Map<OrdK, K, V>, K, V, Func<Map<OrdK, K, V>, V, Map<OrdK, K, V>>)
 - Map<OrdK, K, V> addOrUpdate<OrdK, K, V>(Map<OrdK, K, V>, K, V)
 - Map<OrdK, K, V> addOrUpdate<OrdK, K, V>(Map<OrdK, K, V>, K, Func<V, V>, Func<V>)
 - Map<OrdK, K, V> addOrUpdate<OrdK, K, V>(Map<OrdK, K, V>, K, Func<V, V>, V)
 - Map<OrdK, K, V> addRange<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<Tuple<K, V>>)
 - Map<OrdK, K, V> addRange<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - Map<OrdK, K, V> addRange<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - Map<OrdK, K, V> tryAddRange<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<Tuple<K, V>>)
 - Map<OrdK, K, V> tryAddRange<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - Map<OrdK, K, V> tryAddRange<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - Map<OrdK, K, V> addOrUpdateRange<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<Tuple<K, V>>)
 - Map<OrdK, K, V> addOrUpdateRange<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - Map<OrdK, K, V> addOrUpdateRange<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - Map<OrdK, K, V> remove<OrdK, K, V>(Map<OrdK, K, V>, K)
 - Map<OrdK, K, V> setItem<OrdK, K, V>(Map<OrdK, K, V>, K, V)
 - Map<OrdK, K, V> trySetItem<OrdK, K, V>(Map<OrdK, K, V>, K, V)
 - Map<OrdK, K, V> trySetItem<OrdK, K, V>(Map<OrdK, K, V>, K, Func<V, V>)
 - Map<OrdK, K, V> trySetItem<OrdK, K, V>(Map<OrdK, K, V>, K, Func<V, V>, Func<Map<K, V>, Map<K, V>>)
 - Map<OrdK, K, V> setItems<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<Tuple<K, V>>)
 - Map<OrdK, K, V> setItems<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - Map<OrdK, K, V> setItems<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - Map<OrdK, K, V> trySetItems<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<Tuple<K, V>>)
 - Map<OrdK, K, V> trySetItems<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - Map<OrdK, K, V> trySetItems<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - Map<OrdK, K, V> trySetItems<OrdK, K, V>(Map<OrdK, K, V>, IEnumerable<K>, Func<V, V>)
 - Map<OrdK, K, V> setItem<OrdK, K, V>(Map<OrdK, K, V>, K, Func<V, V>)
 - Map<OrdK, K, U> map<OrdK, K, T, U>(Map<OrdK, K, T>, Func<T, U>)
 - Map<OrdK, K, U> map<OrdK, K, T, U>(Map<OrdK, K, T>, Func<K, T, U>)
 - Map<OrdK, K, V> filter<OrdK, K, V>(Map<OrdK, K, V>, Func<V, bool>)
 - Map<OrdK, K, V> filter<OrdK, K, V>(Map<OrdK, K, V>, Func<K, V, bool>)
 - Map<OrdK, K, R> choose<OrdK, K, T, R>(Map<OrdK, K, T>, Func<T, Option<R>>)
 - Map<OrdK, K, R> choose<OrdK, K, T, R>(Map<OrdK, K, T>, Func<K, T, Option<R>>)
 - Map<OrdK, K, V> freeze<OrdK, K, V>(IDictionary<K, V>)
 - Map<OrdK, K, V> Freeze<OrdK, K, V>(IDictionary<K, V>)
 - Map<OrdK, K, V> union<OrdK, K, V>(Map<OrdK, K, V>, Map<OrdK, K, V>, WhenMatched<K, V, V, V>)
 - Map<OrdK, K, A> union<OrdK, K, A, B>(Map<OrdK, K, A>, Map<OrdK, K, B>, WhenMissing<K, B, A>, WhenMatched<K, A, B, A>)
 - Map<OrdK, K, B> union<OrdK, K, A, B>(Map<OrdK, K, A>, Map<OrdK, K, B>, WhenMissing<K, A, B>, WhenMatched<K, A, B, B>)
 - Map<OrdK, K, C> union<OrdK, K, A, B, C>(Map<OrdK, K, A>, Map<OrdK, K, B>, WhenMissing<K, A, C>, WhenMissing<K, B, C>, WhenMatched<K, A, B, C>)
 - Map<OrdK, K, R> intersect<OrdK, K, A, B, R>(Map<OrdK, K, A>, Map<OrdK, K, B>, WhenMatched<K, A, B, R>)
 - Map<OrdK, K, V> except<OrdK, K, V>(Map<OrdK, K, V>, Map<OrdK, K, V>)
 - Map<OrdK, K, V> symmetricExcept<OrdK, K, V>(Map<OrdK, K, V>, Map<OrdK, K, V>)

 LanguageExt.Seq (LanguageExt.Core 4.0.0.0):
 - Seq<A> flatten<A>(Seq<Seq<A>>)
 - Seq<A> empty<A>()
 - Seq<A> create<A>()
 - Seq<A> create<A>(A[])
 - Seq<A> createRange<A>(IEnumerable<A>)
 - Seq<A> generate<A>(int, Func<int, A>)
 - Seq<A> repeat<A>(A, int)
 - Seq<A> init<A>(Seq<A>)
 - Seq<A> tail<A>(Seq<A>)
 - Seq<B> map<A, B>(Seq<A>, Func<A, B>)
 - Seq<B> map<A, B>(Seq<A>, Func<int, A, B>)
 - Seq<A> filter<A>(Seq<A>, Func<A, bool>)
 - Seq<B> choose<A, B>(Seq<A>, Func<A, Option<B>>)
 - Seq<B> choose<A, B>(Seq<A>, Func<int, A, Option<B>>)
 - Seq<T> rev<T>(Seq<T>)
 - Seq<T> append<T>(Seq<T>, Seq<T>)
 - Seq<T> append<T>(Seq<T>, Seq<Seq<T>>)
 - Seq<T> append<T>(Seq<T>[])
 - Seq<S> scan<S, T>(Seq<T>, S, Func<S, T, S>)
 - Seq<S> scanBack<S, T>(Seq<T>, S, Func<S, T, S>)
 - Seq<T> findSeq<T>(Seq<T>, Func<T, bool>)
 - Seq<V> zip<T, U, V>(Seq<T>, Seq<U>, Func<T, U, V>)
 - Seq<ValueTuple<T, U>> zip<T, U>(Seq<T>, Seq<U>)
 - Seq<T> distinct<T>(Seq<T>)
 - Seq<T> distinct<EQ, T>(Seq<T>)
 - Seq<T> distinct<T, K>(Seq<T>, Func<T, K>, Option<Func<K, K, bool>>)
 - Seq<T> take<T>(Seq<T>, int)
 - Seq<T> takeWhile<T>(Seq<T>, Func<T, bool>)
 - Seq<T> takeWhile<T>(Seq<T>, Func<T, int, bool>)
 - Seq<B> apply<A, B>(Seq<Func<A, B>>, Seq<A>)
 - Seq<B> apply<A, B>(Func<A, B>, Seq<A>)
 - Seq<Func<B, C>> apply<A, B, C>(Seq<Func<A, B, C>>, Seq<A>)
 - Seq<Func<B, C>> apply<A, B, C>(Func<A, B, C>, Seq<A>)
 - Seq<C> apply<A, B, C>(Seq<Func<A, B, C>>, Seq<A>, Seq<B>)
 - Seq<C> apply<A, B, C>(Func<A, B, C>, Seq<A>, Seq<B>)
 - Seq<Func<B, C>> apply<A, B, C>(Seq<Func<A, Func<B, C>>>, Seq<A>)
 - Seq<Func<B, C>> apply<A, B, C>(Func<A, Func<B, C>>, Seq<A>)
 - Seq<C> apply<A, B, C>(Seq<Func<A, Func<B, C>>>, Seq<A>, Seq<B>)
 - Seq<C> apply<A, B, C>(Func<A, Func<B, C>>, Seq<A>, Seq<B>)
 - Seq<B> action<A, B>(Seq<A>, Seq<B>)
 - Seq<Seq<A>> tails<A>(Seq<A>)
 - Seq<Seq<A>> tailsr<A>(Seq<A>)

 LanguageExt.Set (LanguageExt.Core 4.0.0.0):
 - Set<T> create<T>()
 - Set<T> createRange<T>(IEnumerable<T>)
 - Set<T> empty<T>()
 - Set<T> add<T>(Set<T>, T)
 - Set<T> tryAdd<T>(Set<T>, T)
 - Set<T> addOrUpdate<T>(Set<T>, T)
 - Set<A> addRange<A>(Set<A>, IEnumerable<A>)
 - Set<A> tryAddRange<A>(Set<A>, IEnumerable<A>)
 - Set<A> addOrUpdateRange<A>(Set<A>, IEnumerable<A>)
 - Set<T> subtract<T>(Set<T>, Set<T>)
 - Set<T> union<T>(Set<T>, Set<T>)
 - Set<T> filter<T>(Set<T>, Func<T, bool>)
 - Set<T> intersect<T>(Set<T>, IEnumerable<T>)
 - Set<T> except<T>(Set<T>, IEnumerable<T>)
 - Set<T> symmetricExcept<T>(Set<T>, IEnumerable<T>)
 - Set<R> map<T, R>(Set<T>, Func<T, R>)
 - Set<T> remove<T>(Set<T>, T)

 LanguageExt.Set (LanguageExt.Core 4.0.0.0):
 - Set<OrdT, T> create<OrdT, T>()
 - Set<OrdT, T> createRange<OrdT, T>(IEnumerable<T>)
 - Set<OrdT, T> empty<OrdT, T>()
 - Set<OrdT, T> add<OrdT, T>(Set<OrdT, T>, T)
 - Set<OrdT, T> tryAdd<OrdT, T>(Set<OrdT, T>, T)
 - Set<OrdT, T> addOrUpdate<OrdT, T>(Set<OrdT, T>, T)
 - Set<OrdT, T> addRange<OrdT, T>(Set<OrdT, T>, IEnumerable<T>)
 - Set<OrdT, T> tryAddRange<OrdT, T>(Set<OrdT, T>, IEnumerable<T>)
 - Set<OrdT, T> addOrUpdateRange<OrdT, T>(Set<OrdT, T>, IEnumerable<T>)
 - Set<OrdT, T> subtract<OrdT, T>(Set<OrdT, T>, Set<OrdT, T>)
 - Set<OrdT, T> union<OrdT, T>(Set<OrdT, T>, Set<OrdT, T>)
 - Set<OrdT, T> filter<OrdT, T>(Set<OrdT, T>, Func<T, bool>)
 - Set<OrdT, T> intersect<OrdT, T>(Set<OrdT, T>, Set<OrdT, T>)
 - Set<OrdT, T> except<OrdT, T>(Set<OrdT, T>, Set<OrdT, T>)
 - Set<OrdT, T> symmetricExcept<OrdT, T>(Set<OrdT, T>, Set<OrdT, T>)
 - Set<OrdR, R> map<OrdT, OrdR, T, R>(Set<OrdT, T>, Func<T, R>)
 - Set<OrdT, T> map<OrdT, T>(Set<OrdT, T>, Func<T, T>)
 - Set<OrdT, T> remove<OrdT, T>(Set<OrdT, T>, T)

 LanguageExt.TrackingHashMap (LanguageExt.Core 4.0.0.0):
 - TrackingHashMap<K, V> clear<K, V>(TrackingHashMap<K, V>)
 - TrackingHashMap<K, V> empty<K, V>()
 - TrackingHashMap<K, V> create<K, V>()
 - TrackingHashMap<K, V> create<K, V>(Tuple<K, V>, Tuple<K, V>[])
 - TrackingHashMap<K, V> create<K, V>(ValueTuple<K, V>, ValueTuple<K, V>[])
 - TrackingHashMap<K, V> create<K, V>(KeyValuePair<K, V>, KeyValuePair<K, V>[])
 - TrackingHashMap<K, V> createRange<K, V>(IEnumerable<Tuple<K, V>>)
 - TrackingHashMap<K, V> createRange<K, V>(IEnumerable<ValueTuple<K, V>>)
 - TrackingHashMap<K, V> createRange<K, V>(IEnumerable<KeyValuePair<K, V>>)
 - TrackingHashMap<K, V> add<K, V>(TrackingHashMap<K, V>, K, V)
 - TrackingHashMap<K, V> tryAdd<K, V>(TrackingHashMap<K, V>, K, V)
 - TrackingHashMap<K, V> addOrUpdate<K, V>(TrackingHashMap<K, V>, K, V)
 - TrackingHashMap<K, V> addOrUpdate<K, V>(TrackingHashMap<K, V>, K, Func<V, V>, Func<V>)
 - TrackingHashMap<K, V> addOrUpdate<K, V>(TrackingHashMap<K, V>, K, Func<V, V>, V)
 - TrackingHashMap<K, V> addRange<K, V>(TrackingHashMap<K, V>, IEnumerable<Tuple<K, V>>)
 - TrackingHashMap<K, V> addRange<K, V>(TrackingHashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
 - TrackingHashMap<K, V> addRange<K, V>(TrackingHashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - TrackingHashMap<K, V> tryAddRange<K, V>(TrackingHashMap<K, V>, IEnumerable<Tuple<K, V>>)
 - TrackingHashMap<K, V> tryAddRange<K, V>(TrackingHashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
 - TrackingHashMap<K, V> tryAddRange<K, V>(TrackingHashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - TrackingHashMap<K, V> addOrUpdateRange<K, V>(TrackingHashMap<K, V>, IEnumerable<Tuple<K, V>>)
 - TrackingHashMap<K, V> addOrUpdateRange<K, V>(TrackingHashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
 - TrackingHashMap<K, V> addOrUpdateRange<K, V>(TrackingHashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - TrackingHashMap<K, V> remove<K, V>(TrackingHashMap<K, V>, K)
 - TrackingHashMap<K, V> setItem<K, V>(TrackingHashMap<K, V>, K, V)
 - TrackingHashMap<K, V> trySetItem<K, V>(TrackingHashMap<K, V>, K, V)
 - TrackingHashMap<K, V> trySetItem<K, V>(TrackingHashMap<K, V>, K, Func<V, V>)
 - TrackingHashMap<K, V> setItems<K, V>(TrackingHashMap<K, V>, IEnumerable<Tuple<K, V>>)
 - TrackingHashMap<K, V> setItems<K, V>(TrackingHashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
 - TrackingHashMap<K, V> setItems<K, V>(TrackingHashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - TrackingHashMap<K, V> trySetItems<K, V>(TrackingHashMap<K, V>, IEnumerable<Tuple<K, V>>)
 - TrackingHashMap<K, V> trySetItems<K, V>(TrackingHashMap<K, V>, IEnumerable<ValueTuple<K, V>>)
 - TrackingHashMap<K, V> trySetItems<K, V>(TrackingHashMap<K, V>, IEnumerable<KeyValuePair<K, V>>)
 - TrackingHashMap<K, V> trySetItems<K, V>(TrackingHashMap<K, V>, IEnumerable<K>, Func<V, V>)
 - TrackingHashMap<K, V> setItem<K, V>(TrackingHashMap<K, V>, K, Func<V, V>)
 - TrackingHashMap<K, V> filter<K, V>(TrackingHashMap<K, V>, Func<V, bool>)
 - TrackingHashMap<K, V> filter<K, V>(TrackingHashMap<K, V>, Func<K, V, bool>)

 LanguageExt.TrackingHashMap (LanguageExt.Core 4.0.0.0):
 - TrackingHashMap<EqK, K, V> clear<EqK, K, V>(TrackingHashMap<EqK, K, V>)
 - TrackingHashMap<EqK, K, V> empty<EqK, K, V>()
 - TrackingHashMap<EqK, K, V> create<EqK, K, V>()
 - TrackingHashMap<EqK, K, V> create<EqK, K, V>(Tuple<K, V>, Tuple<K, V>[])
 - TrackingHashMap<EqK, K, V> create<EqK, K, V>(ValueTuple<K, V>, ValueTuple<K, V>[])
 - TrackingHashMap<EqK, K, V> create<EqK, K, V>(KeyValuePair<K, V>, KeyValuePair<K, V>[])
 - TrackingHashMap<EqK, K, V> createRange<EqK, K, V>(IEnumerable<Tuple<K, V>>)
 - TrackingHashMap<EqK, K, V> createRange<EqK, K, V>(IEnumerable<ValueTuple<K, V>>)
 - TrackingHashMap<EqK, K, V> createRange<EqK, K, V>(IEnumerable<KeyValuePair<K, V>>)
 - TrackingHashMap<EqK, K, V> add<EqK, K, V>(TrackingHashMap<EqK, K, V>, K, V)
 - TrackingHashMap<EqK, K, V> tryAdd<EqK, K, V>(TrackingHashMap<EqK, K, V>, K, V)
 - TrackingHashMap<EqK, K, V> addOrUpdate<EqK, K, V>(TrackingHashMap<EqK, K, V>, K, V)
 - TrackingHashMap<EqK, K, V> addOrUpdate<EqK, K, V>(TrackingHashMap<EqK, K, V>, K, Func<V, V>, Func<V>)
 - TrackingHashMap<EqK, K, V> addOrUpdate<EqK, K, V>(TrackingHashMap<EqK, K, V>, K, Func<V, V>, V)
 - TrackingHashMap<EqK, K, V> addRange<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
 - TrackingHashMap<EqK, K, V> addRange<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - TrackingHashMap<EqK, K, V> addRange<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - TrackingHashMap<EqK, K, V> tryAddRange<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
 - TrackingHashMap<EqK, K, V> tryAddRange<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - TrackingHashMap<EqK, K, V> tryAddRange<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - TrackingHashMap<EqK, K, V> addOrUpdateRange<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
 - TrackingHashMap<EqK, K, V> addOrUpdateRange<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - TrackingHashMap<EqK, K, V> addOrUpdateRange<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - TrackingHashMap<EqK, K, V> remove<EqK, K, V>(TrackingHashMap<EqK, K, V>, K)
 - TrackingHashMap<EqK, K, V> setItem<EqK, K, V>(TrackingHashMap<EqK, K, V>, K, V)
 - TrackingHashMap<EqK, K, V> trySetItem<EqK, K, V>(TrackingHashMap<EqK, K, V>, K, V)
 - TrackingHashMap<EqK, K, V> trySetItem<EqK, K, V>(TrackingHashMap<EqK, K, V>, K, Func<V, V>)
 - TrackingHashMap<EqK, K, V> setItems<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
 - TrackingHashMap<EqK, K, V> setItems<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - TrackingHashMap<EqK, K, V> setItems<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - TrackingHashMap<EqK, K, V> trySetItems<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<Tuple<K, V>>)
 - TrackingHashMap<EqK, K, V> trySetItems<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<ValueTuple<K, V>>)
 - TrackingHashMap<EqK, K, V> trySetItems<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<KeyValuePair<K, V>>)
 - TrackingHashMap<EqK, K, V> trySetItems<EqK, K, V>(TrackingHashMap<EqK, K, V>, IEnumerable<K>, Func<V, V>)
 - TrackingHashMap<EqK, K, V> setItem<EqK, K, V>(TrackingHashMap<EqK, K, V>, K, Func<V, V>)
 - TrackingHashMap<EqK, K, V> filter<EqK, K, V>(TrackingHashMap<EqK, K, V>, Func<V, bool>)
 - TrackingHashMap<EqK, K, V> filter<EqK, K, V>(TrackingHashMap<EqK, K, V>, Func<K, V, bool>)

 LanguageExt.Lens (LanguageExt.Core 4.0.0.0):
 - Lens<ValueTuple<A, B>, ValueTuple<C, D>> tuple<A, B, C, D>(Lens<A, C>, Lens<B, D>)
 - Lens<ValueTuple<A, B, C>, ValueTuple<D, E, F>> tuple<A, B, C, D, E, F>(Lens<A, D>, Lens<B, E>, Lens<C, F>)
 - Lens<A, B> cond<A, B>(Func<A, bool>, Lens<A, B>, Lens<A, B>)
 - Lens<ValueTuple<A, B>, A> fst<A, B>()
 - Lens<ValueTuple<A, B, C>, A> fst<A, B, C>()
 - Lens<ValueTuple<A, B, C, D>, A> fst<A, B, C, D>()
 - Lens<ValueTuple<A, B>, B> snd<A, B>()
 - Lens<ValueTuple<A, B, C>, B> snd<A, B, C>()
 - Lens<ValueTuple<A, B, C, D>, B> snd<A, B, C, D>()
 - Lens<ValueTuple<A, B, C>, C> thrd<A, B, C>()
 - Lens<ValueTuple<A, B, C, D>, C> thrd<A, B, C, D>()
 - Lens<A, A> identity<A>()
 - Lens<IEnumerable<A>, IEnumerable<B>> enumMap<A, B>(Lens<A, B>)

 LanguageExt.Prism (LanguageExt.Core 4.0.0.0):
 - Prism<A, A> identity<A>()

 LanguageExt.DataTypes.Serialisation.EitherData (LanguageExt.Core 4.0.0.0):
 - EitherData<L, R> Right<L, R>(R)
 - EitherData<L, R> Left<L, R>(L)
 - EitherData<L, R> Bottom<L, R>()

 LanguageExt.Pipes.Client (LanguageExt.Core 4.0.0.0):
 - Client<RT, REQ, RES, R> Pure<RT, REQ, RES, R>(R)
 - Client<RT, REQ, RES, RES> request<RT, REQ, RES>(REQ)
 - Client<RT, REQ, RES, R> lift<RT, REQ, RES, R>(Aff<R>)
 - Client<RT, REQ, RES, R> lift<RT, REQ, RES, R>(Eff<R>)
 - Client<RT, REQ, RES, R> lift<RT, REQ, RES, R>(Aff<RT, R>)
 - Client<RT, REQ, RES, R> lift<RT, REQ, RES, R>(Eff<RT, R>)
 - Client<RT, REQ, RES, R> use<RT, REQ, RES, R>(Aff<R>)
 - Client<RT, REQ, RES, R> use<RT, REQ, RES, R>(Eff<R>)
 - Client<RT, REQ, RES, R> use<RT, REQ, RES, R>(Aff<RT, R>)
 - Client<RT, REQ, RES, R> use<RT, REQ, RES, R>(Eff<RT, R>)
 - Client<RT, REQ, RES, R> use<RT, REQ, RES, R>(Aff<R>, Func<R, Unit>)
 - Client<RT, REQ, RES, R> use<RT, REQ, RES, R>(Eff<R>, Func<R, Unit>)
 - Client<RT, REQ, RES, R> use<RT, REQ, RES, R>(Aff<RT, R>, Func<R, Unit>)
 - Client<RT, REQ, RES, R> use<RT, REQ, RES, R>(Eff<RT, R>, Func<R, Unit>)
 - Client<RT, REQ, RES, Unit> release<RT, REQ, RES, R>(R)

 LanguageExt.Pipes.Consumer (LanguageExt.Core 4.0.0.0):
 - Consumer<RT, A, R> Pure<RT, A, R>(R)
 - Consumer<RT, A, A> awaiting<RT, A>()
 - Consumer<RT, A, R> lift<RT, A, R>(Aff<R>)
 - Consumer<RT, A, R> lift<RT, A, R>(Eff<R>)
 - Consumer<RT, A, R> lift<RT, A, R>(Aff<RT, R>)
 - Consumer<RT, A, R> lift<RT, A, R>(Eff<RT, R>)
 - Consumer<RT, A, Unit> lift<RT, A>(Aff<RT, Unit>)
 - Consumer<RT, A, Unit> lift<RT, A>(Eff<RT, Unit>)
 - Consumer<RT, IN, R> use<RT, IN, R>(Aff<R>)
 - Consumer<RT, IN, R> use<RT, IN, R>(Eff<R>)
 - Consumer<RT, IN, R> use<RT, IN, R>(Aff<RT, R>)
 - Consumer<RT, IN, R> use<RT, IN, R>(Eff<RT, R>)
 - Consumer<RT, IN, R> use<RT, IN, R>(Aff<R>, Func<R, Unit>)
 - Consumer<RT, IN, R> use<RT, IN, R>(Eff<R>, Func<R, Unit>)
 - Consumer<RT, IN, R> use<RT, IN, R>(Aff<RT, R>, Func<R, Unit>)
 - Consumer<RT, IN, R> use<RT, IN, R>(Eff<RT, R>, Func<R, Unit>)
 - Consumer<RT, IN, Unit> release<RT, IN, R>(R)
 - Consumer<RT, A, R> mapM<RT, A, R>(Func<A, Aff<RT, Unit>>)
 - Consumer<RT, A, Unit> mapM<RT, A>(Func<A, Aff<RT, Unit>>)
 - Consumer<RT, A, R> mapM<RT, A, R>(Func<A, Eff<RT, Unit>>)
 - Consumer<RT, A, Unit> mapM<RT, A>(Func<A, Eff<RT, Unit>>)
 - Consumer<RT, A, R> mapM<RT, A, R>(Func<A, Aff<Unit>>)
 - Consumer<RT, A, Unit> mapM<RT, A>(Func<A, Aff<Unit>>)
 - Consumer<RT, A, R> mapM<RT, A, R>(Func<A, Eff<Unit>>)
 - Consumer<RT, A, Unit> mapM<RT, A>(Func<A, Eff<Unit>>)

 LanguageExt.Pipes.Effect (LanguageExt.Core 4.0.0.0):
 - Effect<RT, R> lift<RT, R>(Aff<R>)
 - Effect<RT, R> lift<RT, R>(Eff<R>)
 - Effect<RT, R> lift<RT, R>(Aff<RT, R>)
 - Effect<RT, R> lift<RT, R>(Eff<RT, R>)

 LanguageExt.Pipes.Pipe (LanguageExt.Core 4.0.0.0):
 - Pipe<RT, A, B, R> Pure<RT, A, B, R>(R)
 - Pipe<RT, A, Y, A> awaiting<RT, A, Y>()
 - Pipe<RT, IN, OUT, Unit> yield<RT, IN, OUT>(OUT)
 - Pipe<RT, IN, OUT, Unit> yieldAll<RT, IN, OUT>(IAsyncEnumerable<OUT>)
 - Pipe<RT, IN, OUT, Unit> yieldAll<RT, IN, OUT>(IObservable<OUT>)
 - Pipe<RT, A, A, Unit> filter<RT, A>(Func<A, bool>)
 - Pipe<RT, A, B, R> map<RT, A, B, R>(Func<A, B>)
 - Pipe<RT, A, B, Unit> map<RT, A, B>(Func<A, B>)
 - Pipe<RT, A, B, R> mapM<RT, A, B, R>(Func<A, Aff<RT, B>>)
 - Pipe<RT, A, A, Unit> mapM<RT, A>(Func<A, Aff<RT, A>>)
 - Pipe<RT, A, B, R> mapM<RT, A, B, R>(Func<A, Aff<B>>)
 - Pipe<RT, A, B, R> mapM<RT, A, B, R>(Func<A, Eff<RT, B>>)
 - Pipe<RT, A, A, Unit> mapM<RT, A>(Func<A, Eff<RT, A>>)
 - Pipe<RT, A, B, R> mapM<RT, A, B, R>(Func<A, Eff<B>>)
 - Pipe<RT, A, B, R> lift<RT, A, B, R>(Aff<R>)
 - Pipe<RT, A, B, R> lift<RT, A, B, R>(Eff<R>)
 - Pipe<RT, A, B, R> lift<RT, A, B, R>(Aff<RT, R>)
 - Pipe<RT, A, B, R> lift<RT, A, B, R>(Eff<RT, R>)
 - Pipe<RT, IN, OUT, R> use<RT, IN, OUT, R>(Aff<R>)
 - Pipe<RT, IN, OUT, R> use<RT, IN, OUT, R>(Eff<R>)
 - Pipe<RT, IN, OUT, R> use<RT, IN, OUT, R>(Aff<RT, R>)
 - Pipe<RT, IN, OUT, R> use<RT, IN, OUT, R>(Eff<RT, R>)
 - Pipe<RT, IN, OUT, R> use<RT, IN, OUT, R>(Aff<R>, Func<R, Unit>)
 - Pipe<RT, IN, OUT, R> use<RT, IN, OUT, R>(Eff<R>, Func<R, Unit>)
 - Pipe<RT, IN, OUT, R> use<RT, IN, OUT, R>(Aff<RT, R>, Func<R, Unit>)
 - Pipe<RT, IN, OUT, R> use<RT, IN, OUT, R>(Eff<RT, R>, Func<R, Unit>)
 - Pipe<RT, IN, OUT, Unit> release<RT, IN, OUT, R>(R)
 - Pipe<RT, IN, OUT, Unit> foldWhile<RT, IN, OUT>(OUT, Func<OUT, IN, OUT>, Func<OUT, bool>)
 - Pipe<RT, IN, OUT, Unit> foldUntil<RT, IN, OUT>(OUT, Func<OUT, IN, OUT>, Func<OUT, bool>)
 - Pipe<RT, IN, OUT, Unit> foldWhile<RT, IN, OUT>(OUT, Func<OUT, IN, OUT>, Func<IN, bool>)
 - Pipe<RT, IN, OUT, Unit> foldUntil<RT, IN, OUT>(OUT, Func<OUT, IN, OUT>, Func<IN, bool>)
 - Pipe<RT, IN, OUT, Unit> scan<RT, IN, OUT, S>(Func<S, IN, S>, S, Func<S, OUT>)

 LanguageExt.Pipes.Producer (LanguageExt.Core 4.0.0.0):
 - Producer<RT, OUT, R> Pure<RT, OUT, R>(R)
 - Producer<RT, OUT, Unit> yield<RT, OUT>(OUT)
 - Producer<RT, X, Unit> yieldAll<RT, X>(IEnumerable<X>)
 - Producer<RT, X, Unit> yieldAll<RT, X>(IAsyncEnumerable<X>)
 - Producer<RT, X, Unit> yieldAll<RT, X>(IObservable<X>)
 - Producer<RT, A, Unit> repeatM<RT, A>(Aff<RT, A>)
 - Producer<RT, A, Unit> repeatM<RT, A>(Eff<RT, A>)
 - Producer<RT, A, Unit> repeatM<RT, A>(Aff<A>)
 - Producer<RT, A, Unit> repeatM<RT, A>(Eff<A>)
 - Producer<RT, OUT, R> lift<RT, OUT, R>(Eff<R>)
 - Producer<RT, OUT, R> lift<RT, OUT, R>(Aff<R>)
 - Producer<RT, OUT, R> lift<RT, OUT, R>(Eff<RT, R>)
 - Producer<RT, OUT, R> lift<RT, OUT, R>(Aff<RT, R>)
 - Producer<RT, OUT, R> use<RT, OUT, R>(Aff<R>)
 - Producer<RT, OUT, R> use<RT, OUT, R>(Eff<R>)
 - Producer<RT, OUT, R> use<RT, OUT, R>(Aff<RT, R>)
 - Producer<RT, OUT, R> use<RT, OUT, R>(Eff<RT, R>)
 - Producer<RT, OUT, R> use<RT, OUT, R>(Aff<R>, Func<R, Unit>)
 - Producer<RT, OUT, R> use<RT, OUT, R>(Eff<R>, Func<R, Unit>)
 - Producer<RT, OUT, R> use<RT, OUT, R>(Aff<RT, R>, Func<R, Unit>)
 - Producer<RT, OUT, R> use<RT, OUT, R>(Eff<RT, R>, Func<R, Unit>)
 - Producer<RT, OUT, Unit> release<RT, OUT, R>(R)
 - Producer<RT, S, Unit> FoldUntil<RT, S, A>(Producer<RT, S, A>, S, Func<S, A, S>, Func<A, bool>)
 - Producer<RT, S, Unit> FoldWhile<RT, S, A>(Producer<RT, S, A>, S, Func<S, A, S>, Func<A, bool>)
 - Producer<RT, S, Unit> FoldUntil<RT, S, A>(Producer<RT, S, A>, S, Func<S, A, S>, Func<S, bool>)
 - Producer<RT, S, Unit> FoldWhile<RT, S, A>(Producer<RT, S, A>, S, Func<S, A, S>, Func<S, bool>)
 - Producer<RT, OUT, Unit> merge<RT, OUT>(Seq<Producer<RT, OUT, Unit>>)
 - Producer<RT, OUT, Unit> merge<RT, OUT>(Queue<RT, OUT, Unit>[])
 - Producer<RT, OUT, Unit> merge<RT, OUT>(Producer<RT, OUT, Unit>[])
 - Producer<RT, OUT, Unit> merge<RT, OUT>(Proxy<RT, Void, Unit, Unit, OUT, Unit>[])
 - Producer<RT, OUT, Unit> merge<RT, OUT>(Seq<Queue<RT, OUT, Unit>>)
 - Producer<RT, OUT, Unit> merge<RT, OUT>(Seq<Proxy<RT, Void, Unit, Unit, OUT, Unit>>)

 LanguageExt.Pipes.Proxy (LanguageExt.Core 4.0.0.0):
 - Proxy<RT, A1, A, B1, B, R> lift<RT, A1, A, B1, B, R>(Aff<R>)
 - Proxy<RT, A1, A, B1, B, R> lift<RT, A1, A, B1, B, R>(Eff<R>)
 - Proxy<RT, A1, A, B1, B, R> lift<RT, A1, A, B1, B, R>(Aff<RT, R>)
 - Proxy<RT, A1, A, B1, B, R> lift<RT, A1, A, B1, B, R>(Eff<RT, R>)
 - Proxy<RT, A1, A, B1, B, R> use<RT, A1, A, B1, B, R>(Aff<R>)
 - Proxy<RT, A1, A, B1, B, R> use<RT, A1, A, B1, B, R>(Eff<R>)
 - Proxy<RT, A1, A, B1, B, R> use<RT, A1, A, B1, B, R>(Aff<RT, R>)
 - Proxy<RT, A1, A, B1, B, R> use<RT, A1, A, B1, B, R>(Eff<RT, R>)
 - Proxy<RT, A1, A, B1, B, R> use<RT, A1, A, B1, B, R>(Aff<R>, Func<R, Unit>)
 - Proxy<RT, A1, A, B1, B, R> use<RT, A1, A, B1, B, R>(Eff<R>, Func<R, Unit>)
 - Proxy<RT, A1, A, B1, B, R> use<RT, A1, A, B1, B, R>(Aff<RT, R>, Func<R, Unit>)
 - Proxy<RT, A1, A, B1, B, R> use<RT, A1, A, B1, B, R>(Eff<RT, R>, Func<R, Unit>)
 - Proxy<RT, A1, A, B1, B, Unit> release<RT, A1, A, B1, B, R>(R)
 - Proxy<RT, UOut, UIn, UOut, UIn, A> pull<RT, UOut, UIn, A>(UOut)
 - Proxy<RT, UOut, UIn, UOut, UIn, A> push<RT, UOut, UIn, A>(UIn)
 - Proxy<RT, X1, X, DIn, DOut, DIn> respond<RT, X1, X, DIn, DOut>(DOut)
 - Proxy<RT, UOut, UIn, Y1, Y, UIn> request<RT, UOut, UIn, Y1, Y>(UOut)
 - Proxy<RT, DOut, DIn, UIn, UOut, R> reflect<RT, UOut, UIn, DIn, DOut, R>(Proxy<RT, UOut, UIn, DIn, DOut, R>)
 - Proxy<RT, UOut, UIn, DIn, DOut, B> compose<RT, UOut, UIn, DIn, DOut, A, B>(Proxy<RT, UOut, UIn, DIn, DOut, A>, Proxy<RT, Unit, A, DIn, DOut, B>)
 - Proxy<RT, A1, A, Y1, Y, C> compose<RT, A1, A, Y1, Y, B, C>(Proxy<RT, Unit, B, Y1, Y, C>, Proxy<RT, A1, A, Y1, Y, B>)
 - Proxy<RT, A1, A, Y1, Y, C> compose<RT, A1, A, B1, B, Y1, Y, C>(Func<B1, Proxy<RT, A1, A, Y1, Y, B>>, Proxy<RT, B1, B, Y1, Y, C>)
 - Proxy<RT, A1, A, C1, C, R> compose<RT, A1, A, B1, B, C1, C, R>(Proxy<RT, A1, A, B1, B, R>, Func<B, Proxy<RT, B1, B, C1, C, R>>)
 - Proxy<RT, A1, A, C1, C, R> compose<RT, A1, A, B1, B, C1, C, R>(Func<B1, Proxy<RT, A1, A, B1, B, R>>, Proxy<RT, B1, B, C1, C, R>)
 - Proxy<RT, A1, A, C1, C, R> compose<RT, A1, A, B, C1, C, R>(Proxy<RT, A1, A, Unit, B, R>, Proxy<RT, Unit, B, C1, C, R>)
 - Proxy<RT, X1, X, C1, C, A1> compose<RT, X1, X, A1, B1, C1, C, B>(Proxy<RT, X1, X, B1, B, A1>, Func<B, Proxy<RT, X1, X, C1, C, B1>>)
 - Proxy<RT, X1, X, C1, C, A1> Then<RT, X1, X, A1, B1, C1, C, B>(Proxy<RT, X1, X, B1, B, A1>, Func<B, Proxy<RT, X1, X, C1, C, B1>>)
 - Proxy<RT, A1, A, B1, B, R> observe<RT, A1, A, B1, B, R>(Proxy<RT, A1, A, B1, B, R>)
 - Proxy<RT, A1, A, B1, B, S> apply<RT, A1, A, B1, B, R, S>(Proxy<RT, A1, A, B1, B, Func<R, S>>, Proxy<RT, A1, A, B1, B, R>)
 - Proxy<RT, A1, A, B1, B, S> Apply<RT, A1, A, B1, B, R, S>(Proxy<RT, A1, A, B1, B, Func<R, S>>, Proxy<RT, A1, A, B1, B, R>)
 - Proxy<RT, A1, A, B1, B, S> Action<RT, A1, A, B1, B, R, S>(Proxy<RT, A1, A, B1, B, R>, Proxy<RT, A1, A, B1, B, S>)
 - Proxy<RT, A1, A, B1, B, R> Pure<RT, A1, A, B1, B, R>(R)

 LanguageExt.Pipes.Lift (LanguageExt.Core 4.0.0.0):
 - Lift<RT, A> Pure<RT, A>(A)
 - Lift<RT, A> Aff<RT, A>(Aff<RT, A>)
 - Lift<RT, A> Eff<RT, A>(Eff<RT, A>)
 - Lift<RT, B> Select<RT, A, B>(Lift<RT, A>, Func<A, B>)
 - Lift<RT, B> SelectMany<RT, A, B>(Lift<RT, A>, Func<A, Lift<RT, B>>)
 - Lift<RT, C> SelectMany<RT, A, B, C>(Lift<RT, A>, Func<A, Lift<RT, B>>, Func<A, B, C>)
 - Lift<RT, B> SelectMany<RT, A, B>(Lift<RT, A>, Func<A, Aff<RT, B>>)
 - Lift<RT, C> SelectMany<RT, A, B, C>(Lift<RT, A>, Func<A, Aff<RT, B>>, Func<A, B, C>)
 - Lift<RT, B> SelectMany<RT, A, B>(Lift<RT, A>, Func<A, Eff<RT, B>>)
 - Lift<RT, C> SelectMany<RT, A, B, C>(Lift<RT, A>, Func<A, Eff<RT, B>>, Func<A, B, C>)
 - Lift<RT, B> SelectMany<RT, A, B>(Lift<RT, A>, Func<A, Aff<B>>)
 - Lift<RT, C> SelectMany<RT, A, B, C>(Lift<RT, A>, Func<A, Aff<B>>, Func<A, B, C>)
 - Lift<RT, B> SelectMany<RT, A, B>(Lift<RT, A>, Func<A, Eff<B>>)
 - Lift<RT, C> SelectMany<RT, A, B, C>(Lift<RT, A>, Func<A, Eff<B>>, Func<A, B, C>)

 LanguageExt.Pipes.Pipe (LanguageExt.Core 4.0.0.0):
 - Pipe<A, B, Unit> map<A, B>(Func<A, B>)

 LanguageExt.Pipes.Server (LanguageExt.Core 4.0.0.0):
 - Server<RT, REQ, RES, R> Pure<RT, REQ, RES, R>(R)
 - Server<RT, REQ, RES, REQ> respond<RT, REQ, RES>(RES)
 - Server<RT, REQ, RES, R> lift<RT, REQ, RES, R>(Aff<R>)
 - Server<RT, REQ, RES, R> lift<RT, REQ, RES, R>(Eff<R>)
 - Server<RT, REQ, RES, R> lift<RT, REQ, RES, R>(Aff<RT, R>)
 - Server<RT, REQ, RES, R> lift<RT, REQ, RES, R>(Eff<RT, R>)
 - Server<RT, REQ, RES, R> use<RT, REQ, RES, R>(Aff<R>)
 - Server<RT, REQ, RES, R> use<RT, REQ, RES, R>(Eff<R>)
 - Server<RT, REQ, RES, R> use<RT, REQ, RES, R>(Aff<RT, R>)
 - Server<RT, REQ, RES, R> use<RT, REQ, RES, R>(Eff<RT, R>)
 - Server<RT, REQ, RES, R> use<RT, REQ, RES, R>(Aff<R>, Func<R, Unit>)
 - Server<RT, REQ, RES, R> use<RT, REQ, RES, R>(Eff<R>, Func<R, Unit>)
 - Server<RT, REQ, RES, R> use<RT, REQ, RES, R>(Aff<RT, R>, Func<R, Unit>)
 - Server<RT, REQ, RES, R> use<RT, REQ, RES, R>(Eff<RT, R>, Func<R, Unit>)
 - Server<RT, REQ, RES, Unit> release<RT, REQ, RES, R>(R)

 LanguageExt.Pretty.Doc (LanguageExt.Core 4.0.0.0):
 - Doc<Unit> Char(char)
 - Doc<Unit> Text(string)
 - Doc<Unit> FlatAlt(Doc<Unit>, Doc<Unit>)
 - Doc<Unit> Union(Doc<Unit>, Doc<Unit>)
 - Doc<Unit> Cat(Doc<Unit>, Doc<Unit>)
 - Doc<Unit> Nest(int, Doc<Unit>)
 - Doc<Unit> Column(Func<int, Doc<Unit>>)
 - Doc<Unit> PageWidth(Func<PageWidth, Doc<Unit>>)
 - Doc<Unit> Nesting(Func<int, Doc<Unit>>)
 - Doc<Unit> Group(Doc<Unit>)
 - Doc<Unit> Align(Doc<Unit>)
 - Doc<Unit> Hang(int, Doc<Unit>)
 - Doc<Unit> Indent(int, Doc<Unit>)
 - Doc<Unit> EncloseSep(Doc<Unit>, Doc<Unit>, Doc<Unit>, Seq<Doc<Unit>>)
 - Doc<Unit> EncloseSep(Doc<Unit>, Doc<Unit>, Doc<Unit>, Doc<Unit>[])
 - Doc<Unit> List(Seq<Doc<Unit>>)
 - Doc<Unit> Tuple(Seq<Doc<Unit>>)
 - Doc<Unit> List(Doc<Unit>[])
 - Doc<Unit> Tuple(Doc<Unit>[])
 - Doc<Unit> Spaces(int)
 - Doc<Unit> HorizSep(Seq<Doc<Unit>>)
 - Doc<Unit> VertSep(Seq<Doc<Unit>>)
 - Doc<Unit> Sep(Doc<Unit>, Seq<Doc<Unit>>)
 - Doc<Unit> Sep(Seq<Doc<Unit>>)
 - Doc<Unit> FillSep(Seq<Doc<Unit>>)
 - Doc<Unit> HardSep(Seq<Doc<Unit>>)
 - Doc<Unit> HorizCat(Seq<Doc<Unit>>)
 - Doc<Unit> VertCat(Seq<Doc<Unit>>)
 - Doc<Unit> Width(Doc<Unit>, Func<int, Doc<Unit>>)
 - Doc<Unit> Fill(int, Doc<Unit>)
 - Doc<Unit> Between(Doc<Unit>, Doc<Unit>, Doc<Unit>)
 - readonly Doc<Unit> Fail
 - readonly Doc<Unit> Empty
 - readonly Doc<Unit> HardLine
 - readonly Doc<Unit> LineOrSpace
 - readonly Doc<Unit> LineOrEmpty
 - readonly Doc<Unit> SoftLineOrSpace
 - readonly Doc<Unit> SoftLineOrEmpty

 LanguageExt.Thunks.Thunk (LanguageExt.Core 4.0.0.0):
 - Thunk<A> Flatten<A>(Thunk<Thunk<A>>)

 LanguageExt.Thunks.Thunk (LanguageExt.Core 4.0.0.0):
 - Thunk<Env, A> Flatten<Env, A>(Thunk<Env, Thunk<Env, A>>)
 - Thunk<Env, A> Flatten<Env, A>(Thunk<Thunk<Env, A>>)
 - Thunk<Env, A> Flatten<Env, A>(Thunk<Env, Thunk<A>>)

 LinqToDB.DataProvider.SqlServer.SqlType (linq2db 5.4.1.0):
 - SqlType<Nullable<decimal>> Numeric()
 - SqlType<Nullable<decimal>> Numeric(int)
 - SqlType<Nullable<decimal>> Numeric(int, int)
 - SqlType<Nullable<decimal>> Decimal()
 - SqlType<Nullable<decimal>> Decimal(int)
 - SqlType<Nullable<decimal>> Decimal(int, int)
 - SqlType<Nullable<double>> Float()
 - SqlType<Nullable<double>> Float(int)
 - SqlType<Nullable<DateTimeOffset>> DatetimeOffset()
 - SqlType<Nullable<DateTimeOffset>> DatetimeOffset(int)
 - SqlType<Nullable<DateTime>> Datetime2()
 - SqlType<Nullable<DateTime>> Datetime2(int)
 - SqlType<Nullable<TimeSpan>> Time()
 - SqlType<Nullable<TimeSpan>> Time(int)
 - SqlType<string> Char()
 - SqlType<string> Char(int)
 - SqlType<string> VarChar()
 - SqlType<string> VarChar(int)
 - SqlType<string> NChar()
 - SqlType<string> NChar(int)
 - SqlType<string> NVarChar()
 - SqlType<string> NVarChar(int)
 - SqlType<byte[]> Binary()
 - SqlType<byte[]> Binary(int)
 - SqlType<byte[]> VarBinary()
 - SqlType<byte[]> VarBinary(int)
 - SqlType<object> HierarchyID()
 - SqlType<T> HierarchyID<T>()
 - SqlType<string> Xml()
 - SqlType<T> Xml<T>()
 - SqlType<object> Geometry()
 - SqlType<T> Geometry<T>()
 - SqlType<object> Geography()
 - SqlType<T> Geography<T>()
 - SqlType<Nullable<long>> BigInt { get; }
 - SqlType<Nullable<bool>> Bit { get; }
 - SqlType<Nullable<short>> SmallInt { get; }
 - SqlType<Nullable<decimal>> SmallMoney { get; }
 - SqlType<Nullable<int>> Int { get; }
 - SqlType<Nullable<byte>> TinyInt { get; }
 - SqlType<Nullable<decimal>> Money { get; }
 - SqlType<Nullable<float>> Real { get; }
 - SqlType<Nullable<DateTime>> Date { get; }
 - SqlType<Nullable<DateTime>> SmallDatetime { get; }
 - SqlType<Nullable<DateTime>> Datetime { get; }
 - SqlType<string> CharMax { get; }
 - SqlType<string> VarCharMax { get; }
 - SqlType<string> Text { get; }
 - SqlType<string> NCharMax { get; }
 - SqlType<string> NVarCharMax { get; }
 - SqlType<string> NText { get; }
 - SqlType<byte[]> BinaryMax { get; }
 - SqlType<byte[]> VarBinaryMax { get; }
 - SqlType<byte[]> Image { get; }
 - SqlType<object> Cursor { get; }
 - SqlType<byte[]> RowVersion { get; }
 - SqlType<Nullable<Guid>> UniqueIdentifier { get; }
 - SqlType<object> SqlVariant { get; }
 - SqlType<object> Table { get; }

 LinqToDB.Reflection.TypeAccessor (linq2db 5.4.1.0):
 - TypeAccessor<T> GetAccessor<T>()

 Lucene.Net.Search.FieldCacheRangeFilter (Lucene.Net 3.0.3.0):
 - FieldCacheRangeFilter<string> NewStringRange(string, string, string, bool, bool)
 - FieldCacheRangeFilter<Nullable<sbyte>> NewByteRange(string, Nullable<sbyte>, Nullable<sbyte>, bool, bool)
 - FieldCacheRangeFilter<Nullable<sbyte>> NewByteRange(string, ByteParser, Nullable<sbyte>, Nullable<sbyte>, bool, bool)
 - FieldCacheRangeFilter<Nullable<short>> NewShortRange(string, Nullable<short>, Nullable<short>, bool, bool)
 - FieldCacheRangeFilter<Nullable<short>> NewShortRange(string, ShortParser, Nullable<short>, Nullable<short>, bool, bool)
 - FieldCacheRangeFilter<Nullable<int>> NewIntRange(string, Nullable<int>, Nullable<int>, bool, bool)
 - FieldCacheRangeFilter<Nullable<int>> NewIntRange(string, IntParser, Nullable<int>, Nullable<int>, bool, bool)
 - FieldCacheRangeFilter<Nullable<long>> NewLongRange(string, Nullable<long>, Nullable<long>, bool, bool)
 - FieldCacheRangeFilter<Nullable<long>> NewLongRange(string, LongParser, Nullable<long>, Nullable<long>, bool, bool)
 - FieldCacheRangeFilter<Nullable<float>> NewFloatRange(string, Nullable<float>, Nullable<float>, bool, bool)
 - FieldCacheRangeFilter<Nullable<float>> NewFloatRange(string, FloatParser, Nullable<float>, Nullable<float>, bool, bool)
 - FieldCacheRangeFilter<Nullable<double>> NewDoubleRange(string, Nullable<double>, Nullable<double>, bool, bool)
 - FieldCacheRangeFilter<Nullable<double>> NewDoubleRange(string, DoubleParser, Nullable<double>, Nullable<double>, bool, bool)

 Lucene.Net.Search.NumericRangeFilter (Lucene.Net 3.0.3.0):
 - NumericRangeFilter<long> NewLongRange(string, int, Nullable<long>, Nullable<long>, bool, bool)
 - NumericRangeFilter<long> NewLongRange(string, Nullable<long>, Nullable<long>, bool, bool)
 - NumericRangeFilter<int> NewIntRange(string, int, Nullable<int>, Nullable<int>, bool, bool)
 - NumericRangeFilter<int> NewIntRange(string, Nullable<int>, Nullable<int>, bool, bool)
 - NumericRangeFilter<double> NewDoubleRange(string, int, Nullable<double>, Nullable<double>, bool, bool)
 - NumericRangeFilter<double> NewDoubleRange(string, Nullable<double>, Nullable<double>, bool, bool)
 - NumericRangeFilter<float> NewFloatRange(string, int, Nullable<float>, Nullable<float>, bool, bool)
 - NumericRangeFilter<float> NewFloatRange(string, Nullable<float>, Nullable<float>, bool, bool)

 Lucene.Net.Search.NumericRangeQuery (Lucene.Net 3.0.3.0):
 - NumericRangeQuery<long> NewLongRange(string, int, Nullable<long>, Nullable<long>, bool, bool)
 - NumericRangeQuery<long> NewLongRange(string, Nullable<long>, Nullable<long>, bool, bool)
 - NumericRangeQuery<int> NewIntRange(string, int, Nullable<int>, Nullable<int>, bool, bool)
 - NumericRangeQuery<int> NewIntRange(string, Nullable<int>, Nullable<int>, bool, bool)
 - NumericRangeQuery<double> NewDoubleRange(string, int, Nullable<double>, Nullable<double>, bool, bool)
 - NumericRangeQuery<double> NewDoubleRange(string, Nullable<double>, Nullable<double>, bool, bool)
 - NumericRangeQuery<float> NewFloatRange(string, int, Nullable<float>, Nullable<float>, bool, bool)
 - NumericRangeQuery<float> NewFloatRange(string, Nullable<float>, Nullable<float>, bool, bool)

 Marten.Schema.DocumentMapping (Marten 8.3.1.0):
 - DocumentMapping<T> For<T>(string)

 MongoDB.Bson.Serialization.BsonClassMap (MongoDB.Bson 3.4.0.0):
 - BsonClassMap<TClass> RegisterClassMap<TClass>()
 - BsonClassMap<TClass> RegisterClassMap<TClass>(Action<BsonClassMap<TClass>>)

 MongoDB.Bson.Serialization.Serializers.BinaryVectorSerializer (MongoDB.Bson 3.4.0.0):
 - BinaryVectorSerializer<BinaryVectorFloat32, float> BinaryVectorFloat32Serializer { get; }
 - BinaryVectorSerializer<BinaryVectorInt8, sbyte> BinaryVectorInt8Serializer { get; }
 - BinaryVectorSerializer<BinaryVectorPackedBit, byte> BinaryVectorPackedBitSerializer { get; }

 MongoDB.Driver.Optional (MongoDB.Driver.Core 2.30.0.0):
 - Optional<T> Create<T>(T)
 - Optional<IEnumerable<TItem>> Enumerable<TItem>(IEnumerable<TItem>)

 MongoDB.Driver.AggregateFacet (MongoDB.Driver 3.4.0.0):
 - AggregateFacet<TInput, TOutput> Create<TInput, TOutput>(string, PipelineDefinition<TInput, TOutput>)

 MongoDB.Driver.Optional (MongoDB.Driver 3.4.0.0):
 - Optional<T> Create<T>(T)
 - Optional<IEnumerable<TItem>> Enumerable<TItem>(IEnumerable<TItem>)

 Moq.Mock (Moq 4.20.72.0):
 - Mock<T> Get<T>(T)

 MsgPack.AsyncReadResult (MsgPack 1.0.0.0):
 - AsyncReadResult<T> Success<T>(T)
 - AsyncReadResult<T> Fail<T>()

 MsgPack.Serialization.MessagePackSerializer (MsgPack 1.0.0.0):
 - MessagePackSerializer<T> Create<T>()
 - MessagePackSerializer<T> Create<T>(SerializationContext)
 - MessagePackSerializer<T> Get<T>()
 - MessagePackSerializer<T> Get<T>(object)
 - MessagePackSerializer<T> Get<T>(SerializationContext)
 - MessagePackSerializer<T> Get<T>(SerializationContext, object)

 MvvmCross.Commands.MvxAsyncCommand (MvvmCross 9.3.1.0):
 - MvxAsyncCommand<T> CreateCommand<T>(Func<T, Task>, Func<T, bool>, bool)
 - MvxAsyncCommand<T> CreateCommand<T>(Func<T, CancellationToken, Task>, Func<T, bool>, bool)

 MvvmCross.ViewModels.MvxNotifyTask (MvvmCross 9.3.1.0):
 - MvxNotifyTask<TResult> Create<TResult>(Task<TResult>, TResult, Action<Exception>)
 - MvxNotifyTask<TResult> Create<TResult>(Func<Task<TResult>>, TResult, Action<Exception>)

 NHibernate.Criterion.QueryOver (NHibernate 5.5.0.0):
 - QueryOver<T, T> Of<T>()
 - QueryOver<T, T> Of<T>(Expression<Func<T>>)
 - QueryOver<T, T> Of<T>(string)
 - QueryOver<T, T> Of<T>(string, Expression<Func<T>>)

 NHibernate.Multi.LinqBatchItem (NHibernate 5.5.0.0):
 - LinqBatchItem<TResult> Create<T, TResult>(IQueryable<T>, Expression<Func<IQueryable<T>, TResult>>)
 - LinqBatchItem<T> Create<T>(IQueryable<T>)

 NMemory.Indexes.AnonymousTypeKeyInfo (NMemory 3.0.0.0):
 - AnonymousTypeKeyInfo<TEntity, TKey> Create<TEntity, TKey>(Expression<Func<TEntity, TKey>>)
 - AnonymousTypeKeyInfo<TEntity, TKey> Create<TEntity, TKey>(Expression<Func<TEntity, TKey>>, SortOrder[])

 NMemory.Indexes.PrimitiveKeyInfo (NMemory 3.0.0.0):
 - PrimitiveKeyInfo<TEntity, TKey> Create<TEntity, TKey>(Expression<Func<TEntity, TKey>>)
 - PrimitiveKeyInfo<TEntity, TKey> Create<TEntity, TKey>(Expression<Func<TEntity, TKey>>, SortOrder)

 NMemory.Indexes.TupleKeyInfo (NMemory 3.0.0.0):
 - TupleKeyInfo<TEntity, TKey> Create<TEntity, TKey>(Expression<Func<TEntity, TKey>>, SortOrder[])
 - TupleKeyInfo<TEntity, TKey> Create<TEntity, TKey>(Expression<Func<TEntity, TKey>>)

 NPoco.Sql (NPoco 5.7.1.0):
 - Sql<TContext> BuilderFor<TContext>(TContext)

 NPoco.UpdateBatch (NPoco 5.7.1.0):
 - UpdateBatch<T> For<T>(T, Snapshot<T>)

 NSubstitute.Core.Maybe (NSubstitute 5.3.0.0):
 - Maybe<T> Just<T>(T)
 - Maybe<T> Nothing<T>()

 Omnia.Fx.Models.Search.Shared.SearchApiResponse (Omnia.Fx.Models 7.8.9.0):
 - SearchApiResponse<T> CreateErrorResponse<T>(string, ApiResponseCodes)
 - SearchApiResponse<T> CreateUnauthorizedResponse<T>()
 - SearchApiResponse<T> CreateErrorResponse<T>(Exception)
 - SearchApiResponse<T> CreateSuccessResponse<T>(T)

 OpenCvSharp.Mat (OpenCvSharp 1.0.0.0):
 - Mat<TElem> FromArray<TElem>(TElem[])
 - Mat<TElem> FromArray<TElem>(TElem[])
 - Mat<TElem> FromArray<TElem>(IEnumerable<TElem>)

 Optional.Option (Optional 4.0.0.0):
 - Option<T, TException> Some<T, TException>(T)
 - Option<T, TException> None<T, TException>(TException)

 Optional.Option (Optional 4.0.0.0):
 - Option<T> Some<T>(T)
 - Option<T> None<T>()

 Orleans.Serialization.Buffers.Reader (Orleans.Serialization 9.0.0.0):
 - Reader<BufferSliceReaderInput> Create(PooledBuffer, SerializerSession)
 - Reader<BufferSliceReaderInput> Create(BufferSlice, SerializerSession)
 - Reader<ReaderInput> Create(Stream, SerializerSession)
 - Reader<ReadOnlySequenceInput> Create(ReadOnlySequence<byte>, SerializerSession)
 - Reader<SpanReaderInput> Create(ReadOnlySpan<byte>, SerializerSession)
 - Reader<SpanReaderInput> Create(byte[], SerializerSession)
 - Reader<SpanReaderInput> Create(ReadOnlyMemory<byte>, SerializerSession)

 Orleans.Serialization.Buffers.Writer (Orleans.Serialization 9.0.0.0):
 - Writer<TBufferWriter> Create<TBufferWriter>(TBufferWriter, SerializerSession)
 - Writer<MemoryStreamBufferWriter> Create(MemoryStream, SerializerSession)
 - Writer<PoolingStreamBufferWriter> CreatePooled(Stream, SerializerSession, int)
 - Writer<ArrayStreamBufferWriter> Create(Stream, SerializerSession, int)
 - Writer<SpanBufferWriter> Create(byte[], SerializerSession)
 - Writer<MemoryBufferWriter> Create(Memory<byte>, SerializerSession)
 - Writer<SpanBufferWriter> Create(Span<byte>, SerializerSession)
 - Writer<PooledBuffer> CreatePooled(SerializerSession)

 Paket.FrameworkFolder (Paket.Core 9.0.2.0):
 - FrameworkFolder<b> map<a, b>(FSharpFunc<a, b>, FrameworkFolder<a>)

 Paket.TargetsFolder (Paket.Core 9.0.2.0):
 - TargetsFolder<b> map<a, b>(FSharpFunc<a, b>, TargetsFolder<a>)
 - TargetsFolder<a> mapFrameworkFolders<a>(FSharpFunc<FrameworkFolder<a>, FrameworkFolder<a>>, TargetsFolder<a>)

 Paket.FolderScanner+ParseResult (Paket.Core 9.0.2.0):
 - ParseResult<b> bind<a, b>(FSharpFunc<a, ParseResult<b>>, ParseResult<a>)
 - ParseResult<b> map<a, b>(FSharpFunc<a, b>, ParseResult<a>)
 - ParseResult<object> box<a>(ParseResult<a>)

 Paket.PackageResolver+ResolverTaskMemory (Paket.Core 9.0.2.0):
 - ResolverTaskMemory<a> ofWork<a>(WorkHandle<a>)

 Paket.NetUtils+SafeWebResult (Paket.Core 9.0.2.0):
 - SafeWebResult<b> map<a, b>(FSharpFunc<a, b>, SafeWebResult<a>)

 PeanutButter.Utils.AutoResetter (PeanutButter.Utils 1.0.0.0):
 - AutoResetter<T> Create<T>(Func<T>, Action<T>)

 Pidgin.Maybe (Pidgin 3.5.0.0):
 - Maybe<T> Just<T>(T)
 - Maybe<T> Nothing<T>()

 Pidgin.Parser (Pidgin 3.5.0.0):
 - Parser<char, char> Char(char)
 - Parser<char, char> CIChar(char)
 - Parser<char, char> AnyCharExcept(IEnumerable<char>)
 - Parser<char, char> AnyCharExcept(char[])
 - Parser<char, TEnum> Enum<TEnum>()
 - Parser<char, TEnum> CIEnum<TEnum>()
 - Parser<TToken, T> Lookahead<TToken, T>(Parser<TToken, T>)
 - Parser<TToken, string> ManyString<TToken>(Parser<TToken, char>)
 - Parser<TToken, string> ManyString<TToken>(Parser<TToken, string>)
 - Parser<TToken, string> AtLeastOnceString<TToken>(Parser<TToken, char>)
 - Parser<TToken, string> AtLeastOnceString<TToken>(Parser<TToken, string>)
 - Parser<TToken, R> Map<TToken, T1, R>(Func<T1, R>, Parser<TToken, T1>)
 - Parser<TToken, R> Map<TToken, T1, T2, R>(Func<T1, T2, R>, Parser<TToken, T1>, Parser<TToken, T2>)
 - Parser<TToken, R> Map<TToken, T1, T2, T3, R>(Func<T1, T2, T3, R>, Parser<TToken, T1>, Parser<TToken, T2>, Parser<TToken, T3>)
 - Parser<TToken, R> Map<TToken, T1, T2, T3, T4, R>(Func<T1, T2, T3, T4, R>, Parser<TToken, T1>, Parser<TToken, T2>, Parser<TToken, T3>, Parser<TToken, T4>)
 - Parser<TToken, R> Map<TToken, T1, T2, T3, T4, T5, R>(Func<T1, T2, T3, T4, T5, R>, Parser<TToken, T1>, Parser<TToken, T2>, Parser<TToken, T3>, Parser<TToken, T4>, Parser<TToken, T5>)
 - Parser<TToken, R> Map<TToken, T1, T2, T3, T4, T5, T6, R>(Func<T1, T2, T3, T4, T5, T6, R>, Parser<TToken, T1>, Parser<TToken, T2>, Parser<TToken, T3>, Parser<TToken, T4>, Parser<TToken, T5>, Parser<TToken, T6>)
 - Parser<TToken, R> Map<TToken, T1, T2, T3, T4, T5, T6, T7, R>(Func<T1, T2, T3, T4, T5, T6, T7, R>, Parser<TToken, T1>, Parser<TToken, T2>, Parser<TToken, T3>, Parser<TToken, T4>, Parser<TToken, T5>, Parser<TToken, T6>, Parser<TToken, T7>)
 - Parser<TToken, R> Map<TToken, T1, T2, T3, T4, T5, T6, T7, T8, R>(Func<T1, T2, T3, T4, T5, T6, T7, T8, R>, Parser<TToken, T1>, Parser<TToken, T2>, Parser<TToken, T3>, Parser<TToken, T4>, Parser<TToken, T5>, Parser<TToken, T6>, Parser<TToken, T7>, Parser<TToken, T8>)
 - Parser<TToken, Unit> Not<TToken, T>(Parser<TToken, T>)
 - Parser<char, int> Int(int)
 - Parser<char, int> UnsignedInt(int)
 - Parser<char, long> Long(int)
 - Parser<char, long> UnsignedLong(int)
 - Parser<char, char> OneOf(char[])
 - Parser<char, char> OneOf(IEnumerable<char>)
 - Parser<char, char> CIOneOf(char[])
 - Parser<char, char> CIOneOf(IEnumerable<char>)
 - Parser<TToken, T> OneOf<TToken, T>(Parser<TToken, T>[])
 - Parser<TToken, T> OneOf<TToken, T>(IEnumerable<Parser<TToken, T>>)
 - Parser<TToken, T> Rec<TToken, T>(Func<Parser<TToken, T>>)
 - Parser<TToken, T> Rec<TToken, T>(Func<Parser<TToken, T>, Parser<TToken, T>>)
 - Parser<TToken, T> Rec<TToken, T>(Lazy<Parser<TToken, T>>)
 - Parser<TToken, string> RepeatString<TToken>(Parser<TToken, char>, int)
 - Parser<char, string> String(string)
 - Parser<char, string> CIString(string)
 - Parser<TToken, T> Try<TToken, T>(Parser<TToken, T>)
 - Parser<char, char> Digit { get; }
 - Parser<char, char> Letter { get; }
 - Parser<char, char> LetterOrDigit { get; }
 - Parser<char, char> Lowercase { get; }
 - Parser<char, char> Uppercase { get; }
 - Parser<char, char> Punctuation { get; }
 - Parser<char, char> Symbol { get; }
 - Parser<char, char> Separator { get; }
 - Parser<char, string> EndOfLine { get; }
 - Parser<char, int> DecimalNum { get; }
 - Parser<char, int> Num { get; }
 - Parser<char, long> LongNum { get; }
 - Parser<char, int> OctalNum { get; }
 - Parser<char, int> HexNum { get; }
 - Parser<char, double> Real { get; }
 - Parser<char, char> Whitespace { get; }
 - Parser<char, IEnumerable<char>> Whitespaces { get; }
 - Parser<char, string> WhitespaceString { get; }
 - Parser<char, Unit> SkipWhitespaces { get; }

 Pidgin.Permutation.PermutationParser (Pidgin 3.5.0.0):
 - PermutationParser<TToken, Unit> Create<TToken>()

 Polly.Outcome (Polly.Core 8.0.0.0):
 - Outcome<TResult> FromResult<TResult>(TResult)
 - Outcome<TResult> FromException<TResult>(Exception)

 Polly.Bulkhead.BulkheadPolicy (Polly 8.0.0.0):
 - BulkheadPolicy<TResult> Bulkhead<TResult>(int)
 - BulkheadPolicy<TResult> Bulkhead<TResult>(int, Action<Context>)
 - BulkheadPolicy<TResult> Bulkhead<TResult>(int, int)
 - BulkheadPolicy<TResult> Bulkhead<TResult>(int, int, Action<Context>)

 Polly.Caching.CachePolicy (Polly 8.0.0.0):
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider, TimeSpan, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider, ITtlStrategy, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider, TimeSpan, ICacheKeyStrategy, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider, ITtlStrategy, ICacheKeyStrategy, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider, TimeSpan, Func<Context, string>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider, ITtlStrategy, Func<Context, string>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider, TimeSpan, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider, ITtlStrategy, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider, TimeSpan, ICacheKeyStrategy, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider, ITtlStrategy, ICacheKeyStrategy, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider, TimeSpan, Func<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider, ITtlStrategy, Func<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, TimeSpan, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy<TResult>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, TimeSpan, ICacheKeyStrategy, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy, ICacheKeyStrategy, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy<TResult>, ICacheKeyStrategy, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, TimeSpan, Func<Context, string>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy, Func<Context, string>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy<TResult>, Func<Context, string>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, TimeSpan, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy<TResult>, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, TimeSpan, ICacheKeyStrategy, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy, ICacheKeyStrategy, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy<TResult>, ICacheKeyStrategy, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, TimeSpan, Func<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy, Func<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)
 - CachePolicy<TResult> Cache<TResult>(ISyncCacheProvider<TResult>, ITtlStrategy<TResult>, Func<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string>, Action<Context, string, Exception>, Action<Context, string, Exception>)

 Polly.NoOp.NoOpPolicy (Polly 8.0.0.0):
 - NoOpPolicy<TResult> NoOp<TResult>()

 Polly.RateLimit.RateLimitPolicy (Polly 8.0.0.0):
 - RateLimitPolicy<TResult> RateLimit<TResult>(int, TimeSpan)
 - RateLimitPolicy<TResult> RateLimit<TResult>(int, TimeSpan, Func<TimeSpan, Context, TResult>)
 - RateLimitPolicy<TResult> RateLimit<TResult>(int, TimeSpan, int)
 - RateLimitPolicy<TResult> RateLimit<TResult>(int, TimeSpan, int, Func<TimeSpan, Context, TResult>)

 Polly.Timeout.TimeoutPolicy (Polly 8.0.0.0):
 - TimeoutPolicy<TResult> Timeout<TResult>(int)
 - TimeoutPolicy<TResult> Timeout<TResult>(int, TimeoutStrategy)
 - TimeoutPolicy<TResult> Timeout<TResult>(int, Action<Context, TimeSpan, Task>)
 - TimeoutPolicy<TResult> Timeout<TResult>(int, Action<Context, TimeSpan, Task, Exception>)
 - TimeoutPolicy<TResult> Timeout<TResult>(int, TimeoutStrategy, Action<Context, TimeSpan, Task>)
 - TimeoutPolicy<TResult> Timeout<TResult>(int, TimeoutStrategy, Action<Context, TimeSpan, Task, Exception>)
 - TimeoutPolicy<TResult> Timeout<TResult>(TimeSpan)
 - TimeoutPolicy<TResult> Timeout<TResult>(TimeSpan, TimeoutStrategy)
 - TimeoutPolicy<TResult> Timeout<TResult>(TimeSpan, Action<Context, TimeSpan, Task>)
 - TimeoutPolicy<TResult> Timeout<TResult>(TimeSpan, Action<Context, TimeSpan, Task, Exception>)
 - TimeoutPolicy<TResult> Timeout<TResult>(TimeSpan, TimeoutStrategy, Action<Context, TimeSpan, Task>)
 - TimeoutPolicy<TResult> Timeout<TResult>(TimeSpan, TimeoutStrategy, Action<Context, TimeSpan, Task, Exception>)
 - TimeoutPolicy<TResult> Timeout<TResult>(Func<TimeSpan>)
 - TimeoutPolicy<TResult> Timeout<TResult>(Func<TimeSpan>, TimeoutStrategy)
 - TimeoutPolicy<TResult> Timeout<TResult>(Func<TimeSpan>, Action<Context, TimeSpan, Task>)
 - TimeoutPolicy<TResult> Timeout<TResult>(Func<TimeSpan>, Action<Context, TimeSpan, Task, Exception>)
 - TimeoutPolicy<TResult> Timeout<TResult>(Func<TimeSpan>, TimeoutStrategy, Action<Context, TimeSpan, Task>)
 - TimeoutPolicy<TResult> Timeout<TResult>(Func<TimeSpan>, TimeoutStrategy, Action<Context, TimeSpan, Task, Exception>)
 - TimeoutPolicy<TResult> Timeout<TResult>(Func<Context, TimeSpan>)
 - TimeoutPolicy<TResult> Timeout<TResult>(Func<Context, TimeSpan>, TimeoutStrategy)
 - TimeoutPolicy<TResult> Timeout<TResult>(Func<Context, TimeSpan>, Action<Context, TimeSpan, Task>)
 - TimeoutPolicy<TResult> Timeout<TResult>(Func<Context, TimeSpan>, Action<Context, TimeSpan, Task, Exception>)
 - TimeoutPolicy<TResult> Timeout<TResult>(Func<Context, TimeSpan>, TimeoutStrategy, Action<Context, TimeSpan, Task>)
 - TimeoutPolicy<TResult> Timeout<TResult>(Func<Context, TimeSpan>, TimeoutStrategy, Action<Context, TimeSpan, Task, Exception>)

 Polly.Wrap.PolicyWrap (Polly 8.0.0.0):
 - PolicyWrap<TResult> Wrap<TResult>(ISyncPolicy<TResult>[])

 ProtoBuf.Serializers.EnumSerializer (protobuf-net.Core 3.0.0.0):
 - EnumSerializer<T> CreateSByte<T>()
 - EnumSerializer<T> CreateInt16<T>()
 - EnumSerializer<T> CreateInt32<T>()
 - EnumSerializer<T> CreateInt64<T>()
 - EnumSerializer<T> CreateByte<T>()
 - EnumSerializer<T> CreateUInt16<T>()
 - EnumSerializer<T> CreateUInt32<T>()
 - EnumSerializer<T> CreateUInt64<T>()

 ProtoBuf.Serializers.MapSerializer (protobuf-net.Core 3.0.0.0):
 - MapSerializer<TCollection, TKey, TValue> CreateConcurrentDictionary<TCollection, TKey, TValue>()
 - MapSerializer<Dictionary<TKey, TValue>, TKey, TValue> CreateDictionary<TKey, TValue>()
 - MapSerializer<TCollection, TKey, TValue> CreateDictionary<TCollection, TKey, TValue>()
 - MapSerializer<IReadOnlyDictionary<TKey, TValue>, TKey, TValue> CreateIReadOnlyDictionary<TKey, TValue>()
 - MapSerializer<ImmutableDictionary<TKey, TValue>, TKey, TValue> CreateImmutableDictionary<TKey, TValue>()
 - MapSerializer<ImmutableSortedDictionary<TKey, TValue>, TKey, TValue> CreateImmutableSortedDictionary<TKey, TValue>()
 - MapSerializer<IImmutableDictionary<TKey, TValue>, TKey, TValue> CreateIImmutableDictionary<TKey, TValue>()

 ProtoBuf.Serializers.RepeatedSerializer (protobuf-net.Core 3.0.0.0):
 - RepeatedSerializer<TCollection, T> CreateConcurrentBag<TCollection, T>()
 - RepeatedSerializer<TCollection, T> CreateConcurrentStack<TCollection, T>()
 - RepeatedSerializer<TCollection, T> CreateConcurrentQueue<TCollection, T>()
 - RepeatedSerializer<TCollection, T> CreateIProducerConsumerCollection<TCollection, T>()
 - RepeatedSerializer<TCollection, T> CreateNestedDataNotSupported<TCollection, T>()
 - RepeatedSerializer<TCollection, T> CreateNotSupported<TCollection, T>()
 - RepeatedSerializer<List<T>, T> CreateList<T>()
 - RepeatedSerializer<TList, T> CreateList<TList, T>()
 - RepeatedSerializer<TCollection, T> CreateEnumerable<TCollection, T>()
 - RepeatedSerializer<TCollection, T> CreateEnumerable<TCollection, TCreate, T>()
 - RepeatedSerializer<T[], T> CreateVector<T>()
 - RepeatedSerializer<TCollection, T> CreateQueue<TCollection, T>()
 - RepeatedSerializer<TCollection, T> CreateStack<TCollection, T>()
 - RepeatedSerializer<TCollection, T> CreateSet<TCollection, T>()
 - RepeatedSerializer<IReadOnlySet<T>, T> CreateReadOnySet<T>()
 - RepeatedSerializer<ImmutableArray<T>, T> CreateImmutableArray<T>()
 - RepeatedSerializer<ImmutableList<T>, T> CreateImmutableList<T>()
 - RepeatedSerializer<IImmutableList<T>, T> CreateImmutableIList<T>()
 - RepeatedSerializer<ImmutableQueue<T>, T> CreateImmutableQueue<T>()
 - RepeatedSerializer<IImmutableQueue<T>, T> CreateImmutableIQueue<T>()
 - RepeatedSerializer<ImmutableStack<T>, T> CreateImmutableStack<T>()
 - RepeatedSerializer<IImmutableStack<T>, T> CreateImmutableIStack<T>()
 - RepeatedSerializer<ImmutableHashSet<T>, T> CreateImmutableHashSet<T>()
 - RepeatedSerializer<ImmutableSortedSet<T>, T> CreateImmutableSortedSet<T>()
 - RepeatedSerializer<IImmutableSet<T>, T> CreateImmutableISet<T>()

 Pulumi.Output (Pulumi 3.84.0.0):
 - Output<T> Create<T>(T)
 - Output<T> Create<T>(Task<T>)
 - Output<T> CreateSecret<T>(T)
 - Output<T> CreateSecret<T>(Task<T>)
 - Output<T> CreateSecret<T>(Output<T>)
 - Output<T> Unsecret<T>(Output<T>)
 - Output<ImmutableArray<T>> All<T>(Input<T>[])
 - Output<ImmutableArray<T>> All<T>(IEnumerable<Input<T>>)
 - Output<ImmutableArray<T>> All<T>(Output<T>[])
 - Output<ImmutableArray<T>> All<T>(IEnumerable<Output<T>>)
 - Output<string> Format(FormattableString)
 - Output<string> JsonSerialize<T>(Output<T>, JsonSerializerOptions)
 - Output<T> JsonDeserialize<T>(Output<string>, JsonSerializerOptions)
 - Output<ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8>>> Tuple<T1, T2, T3, T4, T5, T6, T7, T8>(Input<T1>, Input<T2>, Input<T3>, Input<T4>, Input<T5>, Input<T6>, Input<T7>, Input<T8>)
 - Output<ValueTuple<T1, T2>> Tuple<T1, T2>(Input<T1>, Input<T2>)
 - Output<ValueTuple<T1, T2, T3>> Tuple<T1, T2, T3>(Input<T1>, Input<T2>, Input<T3>)
 - Output<ValueTuple<T1, T2, T3, T4>> Tuple<T1, T2, T3, T4>(Input<T1>, Input<T2>, Input<T3>, Input<T4>)
 - Output<ValueTuple<T1, T2, T3, T4, T5>> Tuple<T1, T2, T3, T4, T5>(Input<T1>, Input<T2>, Input<T3>, Input<T4>, Input<T5>)
 - Output<ValueTuple<T1, T2, T3, T4, T5, T6>> Tuple<T1, T2, T3, T4, T5, T6>(Input<T1>, Input<T2>, Input<T3>, Input<T4>, Input<T5>, Input<T6>)
 - Output<ValueTuple<T1, T2, T3, T4, T5, T6, T7>> Tuple<T1, T2, T3, T4, T5, T6, T7>(Input<T1>, Input<T2>, Input<T3>, Input<T4>, Input<T5>, Input<T6>, Input<T7>)
 - Output<ValueTuple<T1, T2>> Tuple<T1, T2>(Output<T1>, Output<T2>)
 - Output<ValueTuple<T1, T2, T3>> Tuple<T1, T2, T3>(Output<T1>, Output<T2>, Output<T3>)
 - Output<ValueTuple<T1, T2, T3, T4>> Tuple<T1, T2, T3, T4>(Output<T1>, Output<T2>, Output<T3>, Output<T4>)
 - Output<ValueTuple<T1, T2, T3, T4, T5>> Tuple<T1, T2, T3, T4, T5>(Output<T1>, Output<T2>, Output<T3>, Output<T4>, Output<T5>)
 - Output<ValueTuple<T1, T2, T3, T4, T5, T6>> Tuple<T1, T2, T3, T4, T5, T6>(Output<T1>, Output<T2>, Output<T3>, Output<T4>, Output<T5>, Output<T6>)
 - Output<ValueTuple<T1, T2, T3, T4, T5, T6, T7>> Tuple<T1, T2, T3, T4, T5, T6, T7>(Output<T1>, Output<T2>, Output<T3>, Output<T4>, Output<T5>, Output<T6>, Output<T7>)
 - Output<ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8>>> Tuple<T1, T2, T3, T4, T5, T6, T7, T8>(Output<T1>, Output<T2>, Output<T3>, Output<T4>, Output<T5>, Output<T6>, Output<T7>, Output<T8>)

 QuikGraph.Algorithms.Condensation.MergedEdge (QuikGraph 2.5.0.0):
 - MergedEdge<TVertex, TEdge> Merge<TVertex, TEdge>(MergedEdge<TVertex, TEdge>, MergedEdge<TVertex, TEdge>)

 Raven.Abstractions.Util.CompletedTask (Raven.Abstractions 3.5.9.0):
 - CompletedTask<T> With<T>(T)

 ReactiveUI.ReactiveCommand (ReactiveUI 20.4.0.0):
 - ReactiveCommand<Unit, Unit> Create(Action, IObservable<bool>, IScheduler)
 - ReactiveCommand<Unit, Unit> CreateRunInBackground(Action, IObservable<bool>, IScheduler, IScheduler)
 - ReactiveCommand<Unit, TResult> Create<TResult>(Func<TResult>, IObservable<bool>, IScheduler)
 - ReactiveCommand<Unit, TResult> CreateRunInBackground<TResult>(Func<TResult>, IObservable<bool>, IScheduler, IScheduler)
 - ReactiveCommand<TParam, Unit> Create<TParam>(Action<TParam>, IObservable<bool>, IScheduler)
 - ReactiveCommand<TParam, Unit> CreateRunInBackground<TParam>(Action<TParam>, IObservable<bool>, IScheduler, IScheduler)
 - ReactiveCommand<TParam, TResult> Create<TParam, TResult>(Func<TParam, TResult>, IObservable<bool>, IScheduler)
 - ReactiveCommand<TParam, TResult> CreateRunInBackground<TParam, TResult>(Func<TParam, TResult>, IObservable<bool>, IScheduler, IScheduler)
 - ReactiveCommand<Unit, TResult> CreateFromObservable<TResult>(Func<IObservable<TResult>>, IObservable<bool>, IScheduler)
 - ReactiveCommand<TParam, TResult> CreateFromObservable<TParam, TResult>(Func<TParam, IObservable<TResult>>, IObservable<bool>, IScheduler)
 - ReactiveCommand<Unit, TResult> CreateFromTask<TResult>(Func<Task<TResult>>, IObservable<bool>, IScheduler)
 - ReactiveCommand<Unit, TResult> CreateFromTask<TResult>(Func<CancellationToken, Task<TResult>>, IObservable<bool>, IScheduler)
 - ReactiveCommand<Unit, Unit> CreateFromTask(Func<Task>, IObservable<bool>, IScheduler)
 - ReactiveCommand<Unit, Unit> CreateFromTask(Func<CancellationToken, Task>, IObservable<bool>, IScheduler)
 - ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(Func<TParam, Task<TResult>>, IObservable<bool>, IScheduler)
 - ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(Func<TParam, CancellationToken, Task<TResult>>, IObservable<bool>, IScheduler)
 - ReactiveCommand<TParam, Unit> CreateFromTask<TParam>(Func<TParam, Task>, IObservable<bool>, IScheduler)
 - ReactiveCommand<TParam, Unit> CreateFromTask<TParam>(Func<TParam, CancellationToken, Task>, IObservable<bool>, IScheduler)

 RepositoryFramework.Entity (RepositoryFramework.Abstractions 9.1.2.0):
 - Entity<T, TKey> Default<T, TKey>(T, TKey)

 RepositoryFramework.State (RepositoryFramework.Abstractions 9.1.2.0):
 - State<T, TKey> Ok<T, TKey>(T, TKey)
 - State<T, TKey> Ok<T, TKey>(Entity<T, TKey>)
 - State<T, TKey> NotOk<T, TKey>(T, TKey)
 - State<T, TKey> NotOk<T, TKey>(Entity<T, TKey>)
 - State<T, TKey> Default<T, TKey>(bool, T, TKey)
 - State<T, TKey> Default<T, TKey>(bool, Entity<T, TKey>)

 ServiceStack.ApiResult (ServiceStack.Client 6.0.0.0):
 - ApiResult<TResponse> Create<TResponse>(TResponse)
 - ApiResult<TResponse> CreateError<TResponse>(ResponseStatus)
 - ApiResult<EmptyResponse> CreateError(ResponseStatus)
 - ApiResult<TResponse> CreateError<TResponse>(string, string)
 - ApiResult<EmptyResponse> CreateError(string, string)
 - ApiResult<TResponse> CreateError<TResponse>(Exception)
 - ApiResult<EmptyResponse> CreateError(Exception)
 - ApiResult<TResponse> CreateFieldError<TResponse>(string, string, string)
 - ApiResult<EmptyResponse> CreateFieldError(string, string, string)

 ServiceStack.MemoryDataSource (ServiceStack 6.0.0.0):
 - MemoryDataSource<T> Create<T>(ICollection<T>, IQueryData, IRequest)

 ServiceStack.PocoDataSource (ServiceStack 6.0.0.0):
 - PocoDataSource<T> Create<T>(ICollection<T>)
 - PocoDataSource<T> Create<T>(IEnumerable<T>, long)
 - PocoDataSource<T> Create<T>(IEnumerable<T>, Func<IEnumerable<T>, long>)
 - PocoDataSource<T> Create<T>(ICollection<T>, Func<IEnumerable<T>, long>)

 ServiceStack.Auth.InMemoryAuthRepository (ServiceStack 6.0.0.0):
 - readonly InMemoryAuthRepository<UserAuth, UserAuthDetails> Instance

 ServiceStack.Messaging.Message (ServiceStack.Interfaces 6.0.0.0):
 - Message<T> Create<T>(T)

 SixLabors.ImageSharp.Image (SixLabors.ImageSharp 3.0.0.0):
 - Image<TPixel> Load<TPixel>(ReadOnlySpan<byte>)
 - Image<TPixel> Load<TPixel>(DecoderOptions, ReadOnlySpan<byte>)
 - Image<TPixel> Load<TPixel>(string)
 - Image<TPixel> Load<TPixel>(DecoderOptions, string)
 - Image<TPixel> Load<TPixel>(Stream)
 - Image<TPixel> Load<TPixel>(DecoderOptions, Stream)
 - Image<TPixel> LoadPixelData<TPixel>(ReadOnlySpan<TPixel>, int, int)
 - Image<TPixel> LoadPixelData<TPixel>(ReadOnlySpan<byte>, int, int)
 - Image<TPixel> LoadPixelData<TPixel>(Configuration, ReadOnlySpan<byte>, int, int)
 - Image<TPixel> LoadPixelData<TPixel>(Configuration, ReadOnlySpan<TPixel>, int, int)
 - Image<TPixel> WrapMemory<TPixel>(Configuration, Memory<TPixel>, int, int, ImageMetadata)
 - Image<TPixel> WrapMemory<TPixel>(Configuration, Memory<TPixel>, int, int)
 - Image<TPixel> WrapMemory<TPixel>(Memory<TPixel>, int, int)
 - Image<TPixel> WrapMemory<TPixel>(Configuration, IMemoryOwner<TPixel>, int, int, ImageMetadata)
 - Image<TPixel> WrapMemory<TPixel>(Configuration, IMemoryOwner<TPixel>, int, int)
 - Image<TPixel> WrapMemory<TPixel>(IMemoryOwner<TPixel>, int, int)
 - Image<TPixel> WrapMemory<TPixel>(Configuration, Memory<byte>, int, int, ImageMetadata)
 - Image<TPixel> WrapMemory<TPixel>(Configuration, Memory<byte>, int, int)
 - Image<TPixel> WrapMemory<TPixel>(Memory<byte>, int, int)
 - Image<TPixel> WrapMemory<TPixel>(Configuration, IMemoryOwner<byte>, int, int, ImageMetadata)
 - Image<TPixel> WrapMemory<TPixel>(Configuration, IMemoryOwner<byte>, int, int)
 - Image<TPixel> WrapMemory<TPixel>(IMemoryOwner<byte>, int, int)
 - Image<TPixel> WrapMemory<TPixel>(Configuration, void*, int, int, int, ImageMetadata)
 - Image<TPixel> WrapMemory<TPixel>(Configuration, void*, int, int, int)
 - Image<TPixel> WrapMemory<TPixel>(void*, int, int, int)

 SixLabors.ImageSharp.Metadata.Profiles.Exif.ExifTag (SixLabors.ImageSharp 3.0.0.0):
 - ExifTag<byte> FaxProfile { get; }
 - ExifTag<byte> ModeNumber { get; }
 - ExifTag<byte> GPSAltitudeRef { get; }
 - ExifTag<byte[]> ClipPath { get; }
 - ExifTag<byte[]> VersionYear { get; }
 - ExifTag<byte[]> XMP { get; }
 - ExifTag<byte[]> IPTC { get; }
 - ExifTag<byte[]> IccProfile { get; }
 - ExifTag<byte[]> CFAPattern2 { get; }
 - ExifTag<byte[]> TIFFEPStandardID { get; }
 - ExifTag<byte[]> GPSVersionID { get; }
 - ExifTag<double[]> PixelScale { get; }
 - ExifTag<double[]> IntergraphMatrix { get; }
 - ExifTag<double[]> ModelTiePoint { get; }
 - ExifTag<double[]> ModelTransform { get; }
 - ExifTag<EncodedString> UserComment { get; }
 - ExifTag<EncodedString> GPSProcessingMethod { get; }
 - ExifTag<EncodedString> GPSAreaInformation { get; }
 - ExifTag<uint> SubfileType { get; }
 - ExifTag<uint> SubIFDOffset { get; }
 - ExifTag<uint> GPSIFDOffset { get; }
 - ExifTag<uint> T4Options { get; }
 - ExifTag<uint> T6Options { get; }
 - ExifTag<uint> XClipPathUnits { get; }
 - ExifTag<uint> YClipPathUnits { get; }
 - ExifTag<uint> ProfileType { get; }
 - ExifTag<uint> CodingMethods { get; }
 - ExifTag<uint> T82ptions { get; }
 - ExifTag<uint> JPEGInterchangeFormat { get; }
 - ExifTag<uint> JPEGInterchangeFormatLength { get; }
 - ExifTag<uint> MDFileTag { get; }
 - ExifTag<uint> StandardOutputSensitivity { get; }
 - ExifTag<uint> RecommendedExposureIndex { get; }
 - ExifTag<uint> ISOSpeed { get; }
 - ExifTag<uint> ISOSpeedLatitudeyyy { get; }
 - ExifTag<uint> ISOSpeedLatitudezzz { get; }
 - ExifTag<uint> FaxRecvParams { get; }
 - ExifTag<uint> FaxRecvTime { get; }
 - ExifTag<uint> ImageNumber { get; }
 - ExifTag<uint[]> FreeOffsets { get; }
 - ExifTag<uint[]> FreeByteCounts { get; }
 - ExifTag<uint[]> ColorResponseUnit { get; }
 - ExifTag<uint[]> SMinSampleValue { get; }
 - ExifTag<uint[]> SMaxSampleValue { get; }
 - ExifTag<uint[]> JPEGQTables { get; }
 - ExifTag<uint[]> JPEGDCTables { get; }
 - ExifTag<uint[]> JPEGACTables { get; }
 - ExifTag<uint[]> StripRowCounts { get; }
 - ExifTag<uint[]> IntergraphRegisters { get; }
 - ExifTag<uint[]> SubIFDs { get; }
 - ExifTag<Number> ImageWidth { get; }
 - ExifTag<Number> ImageLength { get; }
 - ExifTag<Number> RowsPerStrip { get; }
 - ExifTag<Number> TileWidth { get; }
 - ExifTag<Number> TileLength { get; }
 - ExifTag<Number> BadFaxLines { get; }
 - ExifTag<Number> ConsecutiveBadFaxLines { get; }
 - ExifTag<Number> PixelXDimension { get; }
 - ExifTag<Number> PixelYDimension { get; }
 - ExifTag<Number[]> StripOffsets { get; }
 - ExifTag<Number[]> StripByteCounts { get; }
 - ExifTag<Number[]> TileByteCounts { get; }
 - ExifTag<Number[]> TileOffsets { get; }
 - ExifTag<Number[]> ImageLayer { get; }
 - ExifTag<Rational> XPosition { get; }
 - ExifTag<Rational> YPosition { get; }
 - ExifTag<Rational> XResolution { get; }
 - ExifTag<Rational> YResolution { get; }
 - ExifTag<Rational> BatteryLevel { get; }
 - ExifTag<Rational> ExposureTime { get; }
 - ExifTag<Rational> FNumber { get; }
 - ExifTag<Rational> MDScalePixel { get; }
 - ExifTag<Rational> CompressedBitsPerPixel { get; }
 - ExifTag<Rational> ApertureValue { get; }
 - ExifTag<Rational> MaxApertureValue { get; }
 - ExifTag<Rational> SubjectDistance { get; }
 - ExifTag<Rational> FocalLength { get; }
 - ExifTag<Rational> FlashEnergy2 { get; }
 - ExifTag<Rational> FocalPlaneXResolution2 { get; }
 - ExifTag<Rational> FocalPlaneYResolution2 { get; }
 - ExifTag<Rational> ExposureIndex2 { get; }
 - ExifTag<Rational> Humidity { get; }
 - ExifTag<Rational> Pressure { get; }
 - ExifTag<Rational> Acceleration { get; }
 - ExifTag<Rational> FlashEnergy { get; }
 - ExifTag<Rational> FocalPlaneXResolution { get; }
 - ExifTag<Rational> FocalPlaneYResolution { get; }
 - ExifTag<Rational> ExposureIndex { get; }
 - ExifTag<Rational> DigitalZoomRatio { get; }
 - ExifTag<Rational> GPSAltitude { get; }
 - ExifTag<Rational> GPSDOP { get; }
 - ExifTag<Rational> GPSSpeed { get; }
 - ExifTag<Rational> GPSTrack { get; }
 - ExifTag<Rational> GPSImgDirection { get; }
 - ExifTag<Rational> GPSDestBearing { get; }
 - ExifTag<Rational> GPSDestDistance { get; }
 - ExifTag<Rational> GPSHPositioningError { get; }
 - ExifTag<Rational[]> WhitePoint { get; }
 - ExifTag<Rational[]> PrimaryChromaticities { get; }
 - ExifTag<Rational[]> YCbCrCoefficients { get; }
 - ExifTag<Rational[]> ReferenceBlackWhite { get; }
 - ExifTag<Rational[]> GPSLatitude { get; }
 - ExifTag<Rational[]> GPSLongitude { get; }
 - ExifTag<Rational[]> GPSTimestamp { get; }
 - ExifTag<Rational[]> GPSDestLatitude { get; }
 - ExifTag<Rational[]> GPSDestLongitude { get; }
 - ExifTag<Rational[]> LensSpecification { get; }
 - ExifTag<ushort> OldSubfileType { get; }
 - ExifTag<ushort> Compression { get; }
 - ExifTag<ushort> PhotometricInterpretation { get; }
 - ExifTag<ushort> Thresholding { get; }
 - ExifTag<ushort> CellWidth { get; }
 - ExifTag<ushort> CellLength { get; }
 - ExifTag<ushort> FillOrder { get; }
 - ExifTag<ushort> Orientation { get; }
 - ExifTag<ushort> SamplesPerPixel { get; }
 - ExifTag<ushort> PlanarConfiguration { get; }
 - ExifTag<ushort> Predictor { get; }
 - ExifTag<ushort> GrayResponseUnit { get; }
 - ExifTag<ushort> ResolutionUnit { get; }
 - ExifTag<ushort> CleanFaxData { get; }
 - ExifTag<ushort> InkSet { get; }
 - ExifTag<ushort> NumberOfInks { get; }
 - ExifTag<ushort> DotRange { get; }
 - ExifTag<ushort> Indexed { get; }
 - ExifTag<ushort> OPIProxy { get; }
 - ExifTag<ushort> JPEGProc { get; }
 - ExifTag<ushort> JPEGRestartInterval { get; }
 - ExifTag<ushort> YCbCrPositioning { get; }
 - ExifTag<ushort> Rating { get; }
 - ExifTag<ushort> RatingPercent { get; }
 - ExifTag<ushort> ExposureProgram { get; }
 - ExifTag<ushort> Interlace { get; }
 - ExifTag<ushort> SelfTimerMode { get; }
 - ExifTag<ushort> SensitivityType { get; }
 - ExifTag<ushort> MeteringMode { get; }
 - ExifTag<ushort> LightSource { get; }
 - ExifTag<ushort> FocalPlaneResolutionUnit2 { get; }
 - ExifTag<ushort> SensingMethod2 { get; }
 - ExifTag<ushort> Flash { get; }
 - ExifTag<ushort> ColorSpace { get; }
 - ExifTag<ushort> FocalPlaneResolutionUnit { get; }
 - ExifTag<ushort> SensingMethod { get; }
 - ExifTag<ushort> CustomRendered { get; }
 - ExifTag<ushort> ExposureMode { get; }
 - ExifTag<ushort> WhiteBalance { get; }
 - ExifTag<ushort> FocalLengthIn35mmFilm { get; }
 - ExifTag<ushort> SceneCaptureType { get; }
 - ExifTag<ushort> GainControl { get; }
 - ExifTag<ushort> Contrast { get; }
 - ExifTag<ushort> Saturation { get; }
 - ExifTag<ushort> Sharpness { get; }
 - ExifTag<ushort> SubjectDistanceRange { get; }
 - ExifTag<ushort> GPSDifferential { get; }
 - ExifTag<ushort[]> BitsPerSample { get; }
 - ExifTag<ushort[]> MinSampleValue { get; }
 - ExifTag<ushort[]> MaxSampleValue { get; }
 - ExifTag<ushort[]> GrayResponseCurve { get; }
 - ExifTag<ushort[]> ColorMap { get; }
 - ExifTag<ushort[]> ExtraSamples { get; }
 - ExifTag<ushort[]> PageNumber { get; }
 - ExifTag<ushort[]> TransferFunction { get; }
 - ExifTag<ushort[]> HalftoneHints { get; }
 - ExifTag<ushort[]> SampleFormat { get; }
 - ExifTag<ushort[]> TransferRange { get; }
 - ExifTag<ushort[]> DefaultImageColor { get; }
 - ExifTag<ushort[]> JPEGLosslessPredictors { get; }
 - ExifTag<ushort[]> JPEGPointTransforms { get; }
 - ExifTag<ushort[]> YCbCrSubsampling { get; }
 - ExifTag<ushort[]> CFARepeatPatternDim { get; }
 - ExifTag<ushort[]> IntergraphPacketData { get; }
 - ExifTag<ushort[]> ISOSpeedRatings { get; }
 - ExifTag<ushort[]> SubjectArea { get; }
 - ExifTag<ushort[]> SubjectLocation { get; }
 - ExifTag<SignedRational> ShutterSpeedValue { get; }
 - ExifTag<SignedRational> BrightnessValue { get; }
 - ExifTag<SignedRational> ExposureBiasValue { get; }
 - ExifTag<SignedRational> AmbientTemperature { get; }
 - ExifTag<SignedRational> WaterDepth { get; }
 - ExifTag<SignedRational> CameraElevationAngle { get; }
 - ExifTag<SignedRational[]> Decode { get; }
 - ExifTag<short[]> TimeZoneOffset { get; }
 - ExifTag<string> ImageDescription { get; }
 - ExifTag<string> Make { get; }
 - ExifTag<string> Model { get; }
 - ExifTag<string> Software { get; }
 - ExifTag<string> DateTime { get; }
 - ExifTag<string> Artist { get; }
 - ExifTag<string> HostComputer { get; }
 - ExifTag<string> Copyright { get; }
 - ExifTag<string> DocumentName { get; }
 - ExifTag<string> PageName { get; }
 - ExifTag<string> InkNames { get; }
 - ExifTag<string> TargetPrinter { get; }
 - ExifTag<string> ImageID { get; }
 - ExifTag<string> MDLabName { get; }
 - ExifTag<string> MDSampleInfo { get; }
 - ExifTag<string> MDPrepDate { get; }
 - ExifTag<string> MDPrepTime { get; }
 - ExifTag<string> MDFileUnits { get; }
 - ExifTag<string> SEMInfo { get; }
 - ExifTag<string> SpectralSensitivity { get; }
 - ExifTag<string> DateTimeOriginal { get; }
 - ExifTag<string> DateTimeDigitized { get; }
 - ExifTag<string> SubsecTime { get; }
 - ExifTag<string> SubsecTimeOriginal { get; }
 - ExifTag<string> SubsecTimeDigitized { get; }
 - ExifTag<string> RelatedSoundFile { get; }
 - ExifTag<string> FaxSubaddress { get; }
 - ExifTag<string> OffsetTime { get; }
 - ExifTag<string> OffsetTimeOriginal { get; }
 - ExifTag<string> OffsetTimeDigitized { get; }
 - ExifTag<string> SecurityClassification { get; }
 - ExifTag<string> ImageHistory { get; }
 - ExifTag<string> ImageUniqueID { get; }
 - ExifTag<string> OwnerName { get; }
 - ExifTag<string> SerialNumber { get; }
 - ExifTag<string> LensMake { get; }
 - ExifTag<string> LensModel { get; }
 - ExifTag<string> LensSerialNumber { get; }
 - ExifTag<string> GDALMetadata { get; }
 - ExifTag<string> GDALNoData { get; }
 - ExifTag<string> GPSLatitudeRef { get; }
 - ExifTag<string> GPSLongitudeRef { get; }
 - ExifTag<string> GPSSatellites { get; }
 - ExifTag<string> GPSStatus { get; }
 - ExifTag<string> GPSMeasureMode { get; }
 - ExifTag<string> GPSSpeedRef { get; }
 - ExifTag<string> GPSTrackRef { get; }
 - ExifTag<string> GPSImgDirectionRef { get; }
 - ExifTag<string> GPSMapDatum { get; }
 - ExifTag<string> GPSDestLatitudeRef { get; }
 - ExifTag<string> GPSDestLongitudeRef { get; }
 - ExifTag<string> GPSDestBearingRef { get; }
 - ExifTag<string> GPSDestDistanceRef { get; }
 - ExifTag<string> GPSDateStamp { get; }
 - ExifTag<string> XPTitle { get; }
 - ExifTag<string> XPComment { get; }
 - ExifTag<string> XPAuthor { get; }
 - ExifTag<string> XPKeywords { get; }
 - ExifTag<string> XPSubject { get; }
 - ExifTag<byte[]> JPEGTables { get; }
 - ExifTag<byte[]> OECF { get; }
 - ExifTag<byte[]> ExifVersion { get; }
 - ExifTag<byte[]> ComponentsConfiguration { get; }
 - ExifTag<byte[]> MakerNote { get; }
 - ExifTag<byte[]> FlashpixVersion { get; }
 - ExifTag<byte[]> SpatialFrequencyResponse { get; }
 - ExifTag<byte[]> SpatialFrequencyResponse2 { get; }
 - ExifTag<byte[]> Noise { get; }
 - ExifTag<byte[]> CFAPattern { get; }
 - ExifTag<byte[]> DeviceSettingDescription { get; }
 - ExifTag<byte[]> ImageSourceData { get; }
 - ExifTag<byte> FileSource { get; }
 - ExifTag<byte> SceneType { get; }

 SqlSugar.Expressionable (SqlSugar 5.1.4.197):
 - Expressionable<T> Create<T>()

 SqlSugar.Expressionable (SqlSugar 5.1.4.197):
 - Expressionable<T, T2> Create<T, T2>()

 SqlSugar.Expressionable (SqlSugar 5.1.4.197):
 - Expressionable<T, T2, T3> Create<T, T2, T3>()

 SqlSugar.Expressionable (SqlSugar 5.1.4.197):
 - Expressionable<T, T2, T3, T4> Create<T, T2, T3, T4>()

 SqlSugar.Expressionable (SqlSugar 5.1.4.197):
 - Expressionable<T, T2, T3, T4, T5> Create<T, T2, T3, T4, T5>()

 SqlSugar.Expressionable (SqlSugar 5.1.4.197):
 - Expressionable<T, T2, T3, T4, T5, T6> Create<T, T2, T3, T4, T5, T6>()

 SqlSugar.Expressionable (SqlSugar 5.1.4.197):
 - Expressionable<T, T2, T3, T4, T5, T6, T7> Create<T, T2, T3, T4, T5, T6, T7>()

 SqlSugar.Expressionable (SqlSugar 5.1.4.197):
 - Expressionable<T, T2, T3, T4, T5, T6, T7, T8> Create<T, T2, T3, T4, T5, T6, T7, T8>()

 SqlSugar.Expressionable (SqlSugar 5.1.4.197):
 - Expressionable<T, T2, T3, T4, T5, T6, T7, T8, T9> Create<T, T2, T3, T4, T5, T6, T7, T8, T9>()

 SqlSugar.Expressionable (SqlSugar 5.1.4.197):
 - Expressionable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Create<T, T2, T3, T4, T5, T6, T7, T8, T9, T10>()

 SqlSugar.Expressionable (SqlSugar 5.1.4.197):
 - Expressionable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Create<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>()

 SqlSugar.Expressionable (SqlSugar 5.1.4.197):
 - Expressionable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Create<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>()

 Superpower.Model.Result (Superpower 1.0.0.0):
 - Result<T> Empty<T>(TextSpan)
 - Result<T> Empty<T>(TextSpan, string[])
 - Result<T> Empty<T>(TextSpan, string)
 - Result<T> Value<T>(T, TextSpan, TextSpan)
 - Result<U> CastEmpty<T, U>(Result<T>)
 - Result<T> CombineEmpty<T>(Result<T>, Result<T>)

 Superpower.Model.TokenListParserResult (Superpower 1.0.0.0):
 - TokenListParserResult<TKind, T> Empty<TKind, T>(TokenList<TKind>)
 - TokenListParserResult<TKind, T> Empty<TKind, T>(TokenList<TKind>, string[])
 - TokenListParserResult<TKind, T> Empty<TKind, T>(TokenList<TKind>, TKind[])
 - TokenListParserResult<TKind, T> Empty<TKind, T>(TokenList<TKind>, string)
 - TokenListParserResult<TKind, T> Empty<TKind, T>(TokenList<TKind>, Position, string)
 - TokenListParserResult<TKind, T> Value<TKind, T>(T, TokenList<TKind>, TokenList<TKind>)
 - TokenListParserResult<TKind, U> CastEmpty<TKind, T, U>(TokenListParserResult<TKind, T>)
 - TokenListParserResult<TKind, T> CombineEmpty<TKind, T>(TokenListParserResult<TKind, T>, TokenListParserResult<TKind, T>)

 Swashbuckle.AspNetCore.Filters.SwaggerExample (Swashbuckle.AspNetCore.Filters.Abstractions 9.0.0.0):
 - SwaggerExample<T> Create<T>(string, T)
 - SwaggerExample<T> Create<T>(string, string, T)
 - SwaggerExample<T> Create<T>(string, string, string, T)

 Tesserae.SettableObservable (tss 0.0.0.0):
 - SettableObservable<T> For<T>(T, IEqualityComparer<T>)

 Umbraco.Cms.Core.Attempt (Umbraco.Core 16.0.0.0):
 - Attempt<TResult> Succeed<TResult>(TResult)
 - Attempt<TResult> Fail<TResult>()
 - Attempt<TResult> Fail<TResult>(TResult)
 - Attempt<TResult> Fail<TResult>(TResult, Exception)
 - Attempt<TResult> If<TResult>(bool, TResult)

 Umbraco.Cms.Core.Attempt (Umbraco.Core 16.0.0.0):
 - Attempt<TResult, TStatus> SucceedWithStatus<TResult, TStatus>(TStatus, TResult)
 - Attempt<TResult, TStatus> FailWithStatus<TResult, TStatus>(TStatus, TResult)
 - Attempt<TResult, TStatus> FailWithStatus<TResult, TStatus>(TStatus, TResult, Exception)
 - Attempt<TResult, TStatus> IfWithStatus<TResult, TStatus>(bool, TStatus, TStatus, TResult)

 Umbraco.Cms.Core.Deploy.ArtifactDeployState (Umbraco.Core 16.0.0.0):
 - ArtifactDeployState<TArtifact, TEntity> Create<TArtifact, TEntity>(TArtifact, TEntity, IServiceConnector, int)

 Unity.Interception.Utilities.Pair (Unity.Interception 5.11.1.0):
 - Pair<TFirstParameter, TSecondParameter> Make<TFirstParameter, TSecondParameter>(TFirstParameter, TSecondParameter)

 Uno.Diagnostics.UI.DiagnosticView (Uno.UI.Toolkit 255.255.255.255):
 - DiagnosticView<TView> Register<TView>(string, DiagnosticViewRegistrationMode, DiagnosticViewRegistrationPosition)
 - DiagnosticView<TView> Register<TView>(string, Func<TView>, DiagnosticViewRegistrationMode, DiagnosticViewRegistrationPosition)

 Uno.Diagnostics.UI.DiagnosticView (Uno.UI.Toolkit 255.255.255.255):
 - DiagnosticView<TView, TState> Register<TView, TState>(string, Action<TView, TState>, Func<TState, object>, DiagnosticViewRegistrationMode, DiagnosticViewRegistrationPosition)
 - DiagnosticView<TView, TState> Register<TView, TState>(string, Func<IDiagnosticViewContext, TView>, Action<TView, TState>, Func<TState, object>, DiagnosticViewRegistrationMode, DiagnosticViewRegistrationPosition)

 Uno.Diagnostics.UI.DiagnosticView (Uno.UI 255.255.255.255):
 - DiagnosticView<TView> Register<TView>(string, DiagnosticViewRegistrationMode, DiagnosticViewRegistrationPosition)
 - DiagnosticView<TView> Register<TView>(string, Func<TView>, DiagnosticViewRegistrationMode, DiagnosticViewRegistrationPosition)

 Uno.Diagnostics.UI.DiagnosticView (Uno.UI 255.255.255.255):
 - DiagnosticView<TView, TState> Register<TView, TState>(string, Action<TView, TState>, Func<TState, object>, DiagnosticViewRegistrationMode, DiagnosticViewRegistrationPosition)
 - DiagnosticView<TView, TState> Register<TView, TState>(string, Func<IDiagnosticViewContext, TView>, Action<TView, TState>, Func<TState, object>, DiagnosticViewRegistrationMode, DiagnosticViewRegistrationPosition)

 uSync.Core.Dependency.GraphEdge (uSync.Core 16.0.0.0):
 - GraphEdge<T> Create<T>(T, T)

 Xamarin.Forms.Internals.Registrar (Xamarin.Forms.Core 2.0.0.0):
 - Registrar<IRegisterable> Registered { get; set; }

 Xunit.Sdk.CollectionTracker (xunit.v3.assert 2.0.3.0):
 - CollectionTracker<object> Wrap(IEnumerable)