diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeBag`1+Enumerator.cs b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeBag`1+Enumerator.cs
new file mode 100644
index 0000000..d7e12d2
--- /dev/null
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeBag`1+Enumerator.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace TunnelVisionLabs.Collections.Trees.Concurrent
+{
+    using System.Collections;
+    using System.Collections.Generic;
+
+    public partial class ConcurrentTreeBag<T>
+    {
+        public struct Enumerator : IEnumerator<T>
+        {
+            public T Current => throw null!;
+
+            object? IEnumerator.Current => throw null!;
+
+            public void Dispose() => throw null!;
+
+            public bool MoveNext() => throw null!;
+
+            public void Reset() => throw null!;
+        }
+    }
+}
diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeBag`1.cs b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeBag`1.cs
new file mode 100644
index 0000000..fe919e3
--- /dev/null
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeBag`1.cs
@@ -0,0 +1,48 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace TunnelVisionLabs.Collections.Trees.Concurrent
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+
+    public partial class ConcurrentTreeBag<T> : IProducerConsumerCollection<T>, IReadOnlyCollection<T>
+    {
+        public ConcurrentTreeBag() => throw null!;
+
+        public ConcurrentTreeBag(IEnumerable<T> collection) => throw null!;
+
+        public int Count => throw null!;
+
+        public bool IsEmpty => throw null!;
+
+        bool ICollection.IsSynchronized => throw null!;
+
+        object ICollection.SyncRoot => throw null!;
+
+        public void Add(T item) => throw null!;
+
+        public void Clear() => throw null!;
+
+        public void CopyTo(T[] array, int index) => throw null!;
+
+        public Enumerator GetEnumerator() => throw null!;
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator() => throw null!;
+
+        IEnumerator IEnumerable.GetEnumerator() => throw null!;
+
+        public T[] ToArray() => throw null!;
+
+        public bool TryPeek([MaybeNullWhen(false)] out T result) => throw null!;
+
+        public bool TryTake([MaybeNullWhen(false)] out T result) => throw null!;
+
+        void ICollection.CopyTo(Array array, int index) => throw null!;
+
+        bool IProducerConsumerCollection<T>.TryAdd(T item) => throw null!;
+    }
+}
diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+Enumerator.cs b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+Enumerator.cs
new file mode 100644
index 0000000..fe84d64
--- /dev/null
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+Enumerator.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace TunnelVisionLabs.Collections.Trees.Concurrent
+{
+    using System.Collections;
+    using System.Collections.Generic;
+
+    public partial class ConcurrentTreeDictionary<TKey, TValue>
+    {
+        public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>
+        {
+            public KeyValuePair<TKey, TValue> Current => throw null!;
+
+            object? IEnumerator.Current => throw null!;
+
+            public void Dispose() => throw null!;
+
+            public bool MoveNext() => throw null!;
+
+            public void Reset() => throw null!;
+        }
+    }
+}
diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+KeyCollection+Enumerator.cs b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+KeyCollection+Enumerator.cs
new file mode 100644
index 0000000..d1e9b59
--- /dev/null
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+KeyCollection+Enumerator.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace TunnelVisionLabs.Collections.Trees.Concurrent
+{
+    using System.Collections;
+    using System.Collections.Generic;
+
+    public partial class ConcurrentTreeDictionary<TKey, TValue>
+    {
+        public partial struct KeyCollection
+        {
+            public struct Enumerator : IEnumerator<TKey>
+            {
+                public TKey Current => throw null!;
+
+                object IEnumerator.Current => throw null!;
+
+                public void Dispose() => throw null!;
+
+                public bool MoveNext() => throw null!;
+
+                public void Reset() => throw null!;
+            }
+        }
+    }
+}
diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+KeyCollection.cs b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+KeyCollection.cs
new file mode 100644
index 0000000..49ef52f
--- /dev/null
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+KeyCollection.cs
@@ -0,0 +1,35 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace TunnelVisionLabs.Collections.Trees.Concurrent
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+
+    public partial class ConcurrentTreeDictionary<TKey, TValue>
+    {
+        public partial struct KeyCollection : IReadOnlyCollection<TKey>, ICollection<TKey>
+        {
+            public int Count => throw null!;
+
+            bool ICollection<TKey>.IsReadOnly => throw null!;
+
+            public Enumerator GetEnumerator() => throw null!;
+
+            public bool Contains(TKey item) => throw null!;
+
+            public void Clear() => throw new NotSupportedException();
+
+            public bool Remove(TKey item) => throw new NotSupportedException();
+
+            IEnumerator<TKey> IEnumerable<TKey>.GetEnumerator() => throw null!;
+
+            IEnumerator IEnumerable.GetEnumerator() => throw null!;
+
+            void ICollection<TKey>.CopyTo(TKey[] array, int arrayIndex) => throw null!;
+
+            void ICollection<TKey>.Add(TKey item) => throw new NotSupportedException();
+        }
+    }
+}
diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+ValueCollection+Enumerator.cs b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+ValueCollection+Enumerator.cs
new file mode 100644
index 0000000..ad8bded
--- /dev/null
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+ValueCollection+Enumerator.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace TunnelVisionLabs.Collections.Trees.Concurrent
+{
+    using System.Collections;
+    using System.Collections.Generic;
+
+    public partial class ConcurrentTreeDictionary<TKey, TValue>
+    {
+        public partial struct ValueCollection
+        {
+            public struct Enumerator : IEnumerator<TValue>
+            {
+                public TValue Current => throw null!;
+
+                object? IEnumerator.Current => throw null!;
+
+                public void Dispose() => throw null!;
+
+                public bool MoveNext() => throw null!;
+
+                public void Reset() => throw null!;
+            }
+        }
+    }
+}
diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+ValueCollection.cs b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+ValueCollection.cs
new file mode 100644
index 0000000..e6137eb
--- /dev/null
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2+ValueCollection.cs
@@ -0,0 +1,35 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace TunnelVisionLabs.Collections.Trees.Concurrent
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+
+    public partial class ConcurrentTreeDictionary<TKey, TValue>
+    {
+        public partial struct ValueCollection : IReadOnlyCollection<TValue>, ICollection<TValue>
+        {
+            public int Count => throw null!;
+
+            bool ICollection<TValue>.IsReadOnly => throw null!;
+
+            public Enumerator GetEnumerator() => throw null!;
+
+            public bool Contains(TValue item) => throw null!;
+
+            IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator() => throw null!;
+
+            IEnumerator IEnumerable.GetEnumerator() => throw null!;
+
+            void ICollection<TValue>.CopyTo(TValue[] array, int arrayIndex) => throw null!;
+
+            void ICollection<TValue>.Add(TValue item) => throw new NotSupportedException();
+
+            void ICollection<TValue>.Clear() => throw new NotSupportedException();
+
+            bool ICollection<TValue>.Remove(TValue item) => throw new NotSupportedException();
+        }
+    }
+}
diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2.cs b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2.cs
new file mode 100644
index 0000000..eb0b069
--- /dev/null
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeDictionary`2.cs
@@ -0,0 +1,125 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace TunnelVisionLabs.Collections.Trees.Concurrent
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+
+    public partial class ConcurrentTreeDictionary<TKey, TValue>
+        : IDictionary<TKey, TValue>, IReadOnlyDictionary<TKey, TValue>, IDictionary
+        where TKey : notnull
+    {
+        public ConcurrentTreeDictionary() => throw null!;
+
+        public ConcurrentTreeDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection) => throw null!;
+
+        public ConcurrentTreeDictionary(IEqualityComparer<TKey>? comparer) => throw null!;
+
+        public ConcurrentTreeDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey>? comparer) => throw null!;
+
+        public ConcurrentTreeDictionary(int concurrencyLevel, int capacity) => throw null!;
+
+        public ConcurrentTreeDictionary(int concurrencyLevel, IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey>? comparer) => throw null!;
+
+        public ConcurrentTreeDictionary(int concurrencyLevel, int capacity, IEqualityComparer<TKey>? comparer) => throw null!;
+
+        public int Count => throw null!;
+
+        public bool IsEmpty => throw null!;
+
+        public KeyCollection Keys => throw null!;
+
+        public ValueCollection Values => throw null!;
+
+        bool ICollection.IsSynchronized => throw null!;
+
+        object ICollection.SyncRoot => throw null!;
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => throw null!;
+
+        bool IDictionary.IsFixedSize => throw null!;
+
+        bool IDictionary.IsReadOnly => throw null!;
+
+        ICollection IDictionary.Keys => throw null!;
+
+        ICollection IDictionary.Values => throw null!;
+
+        ICollection<TKey> IDictionary<TKey, TValue>.Keys => throw null!;
+
+        ICollection<TValue> IDictionary<TKey, TValue>.Values => throw null!;
+
+        IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys => throw null!;
+
+        IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values => throw null!;
+
+        public TValue this[TKey key]
+        {
+            get => throw null!;
+            set => throw null!;
+        }
+
+        object? IDictionary.this[object key]
+        {
+            get => throw null!;
+            set => throw null!;
+        }
+
+        public TValue AddOrUpdate(TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory) => throw null!;
+
+        public TValue AddOrUpdate(TKey key, TValue addValue, Func<TKey, TValue, TValue> updateValueFactory) => throw null!;
+
+        public TValue AddOrUpdate<TArg>(TKey key, Func<TKey, TArg, TValue> addValueFactory, Func<TKey, TValue, TArg, TValue> updateValueFactory, TArg factoryArgument) => throw null!;
+
+        public void Clear() => throw null!;
+
+        public bool ContainsKey(TKey key) => throw null!;
+
+        public Enumerator GetEnumerator() => throw null!;
+
+        public TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory) => throw null!;
+
+        public TValue GetOrAdd(TKey key, TValue value) => throw null!;
+
+        public TValue GetOrAdd<TArg>(TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument) => throw null!;
+
+        public KeyValuePair<TKey, TValue>[] ToArray() => throw null!;
+
+        public bool TryAdd(TKey key, TValue value) => throw null!;
+
+        public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value) => throw null!;
+
+        public bool TryRemove(TKey key, [MaybeNullWhen(false)] out TValue value) => throw null!;
+
+        public bool TryUpdate(TKey key, TValue newValue, TValue comparisonValue) => throw null!;
+
+        void ICollection.CopyTo(Array array, int index) => throw null!;
+
+        void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item) => throw null!;
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) => throw null!;
+
+        void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) => throw null!;
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item) => throw null!;
+
+        void IDictionary.Add(object key, object? value) => throw null!;
+
+        bool IDictionary.Contains(object key) => throw null!;
+
+        IDictionaryEnumerator IDictionary.GetEnumerator() => throw null!;
+
+        void IDictionary.Remove(object key) => throw null!;
+
+        void IDictionary<TKey, TValue>.Add(TKey key, TValue value) => throw null!;
+
+        bool IDictionary<TKey, TValue>.Remove(TKey key) => throw null!;
+
+        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator() => throw null!;
+
+        IEnumerator IEnumerable.GetEnumerator() => throw null!;
+    }
+}
diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeQueue`1+Enumerator.cs b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeQueue`1+Enumerator.cs
new file mode 100644
index 0000000..841e240
--- /dev/null
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeQueue`1+Enumerator.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace TunnelVisionLabs.Collections.Trees.Concurrent
+{
+    using System.Collections;
+    using System.Collections.Generic;
+
+    public partial class ConcurrentTreeQueue<T>
+    {
+        public struct Enumerator : IEnumerator<T>
+        {
+            public T Current => throw null!;
+
+            object? IEnumerator.Current => throw null!;
+
+            public void Dispose() => throw null!;
+
+            public bool MoveNext() => throw null!;
+
+            public void Reset() => throw null!;
+        }
+    }
+}
diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeQueue`1.cs b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeQueue`1.cs
new file mode 100644
index 0000000..d6e257f
--- /dev/null
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeQueue`1.cs
@@ -0,0 +1,50 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace TunnelVisionLabs.Collections.Trees.Concurrent
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+
+    public partial class ConcurrentTreeQueue<T> : IProducerConsumerCollection<T>, IReadOnlyCollection<T>
+    {
+        public ConcurrentTreeQueue() => throw null!;
+
+        public ConcurrentTreeQueue(IEnumerable<T> collection) => throw null!;
+
+        public int Count => throw null!;
+
+        public bool IsEmpty => throw null!;
+
+        bool ICollection.IsSynchronized => throw null!;
+
+        object ICollection.SyncRoot => throw null!;
+
+        public void Clear() => throw null!;
+
+        public void CopyTo(T[] array, int index) => throw null!;
+
+        public void Enqueue(T item) => throw null!;
+
+        public Enumerator GetEnumerator() => throw null!;
+
+        public T[] ToArray() => throw null!;
+
+        public bool TryDequeue([MaybeNullWhen(false)] out T result) => throw null!;
+
+        public bool TryPeek([MaybeNullWhen(false)] out T result) => throw null!;
+
+        void ICollection.CopyTo(Array array, int index) => throw null!;
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator() => throw null!;
+
+        IEnumerator IEnumerable.GetEnumerator() => throw null!;
+
+        bool IProducerConsumerCollection<T>.TryAdd(T item) => throw null!;
+
+        bool IProducerConsumerCollection<T>.TryTake([MaybeNullWhen(false)] out T item) => throw null!;
+    }
+}
diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeStack`1+Enumerator.cs b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeStack`1+Enumerator.cs
new file mode 100644
index 0000000..77b1f38
--- /dev/null
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeStack`1+Enumerator.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace TunnelVisionLabs.Collections.Trees.Concurrent
+{
+    using System.Collections;
+    using System.Collections.Generic;
+
+    public partial class ConcurrentTreeStack<T>
+    {
+        public struct Enumerator : IEnumerator<T>
+        {
+            public T Current => throw null!;
+
+            object? IEnumerator.Current => throw null!;
+
+            public void Dispose() => throw null!;
+
+            public bool MoveNext() => throw null!;
+
+            public void Reset() => throw null!;
+        }
+    }
+}
diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeStack`1.cs b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeStack`1.cs
new file mode 100644
index 0000000..8332985
--- /dev/null
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/Concurrent/ConcurrentTreeStack`1.cs
@@ -0,0 +1,58 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace TunnelVisionLabs.Collections.Trees.Concurrent
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+
+    public partial class ConcurrentTreeStack<T> : IProducerConsumerCollection<T>, IReadOnlyCollection<T>
+    {
+        public ConcurrentTreeStack() => throw null!;
+
+        public ConcurrentTreeStack(IEnumerable<T> collection) => throw null!;
+
+        public int Count => throw null!;
+
+        public bool IsEmpty => throw null!;
+
+        bool ICollection.IsSynchronized => throw null!;
+
+        object ICollection.SyncRoot => throw null!;
+
+        public void Clear() => throw null!;
+
+        public void CopyTo(T[] array, int index) => throw null!;
+
+        public Enumerator GetEnumerator() => throw null!;
+
+        public void Push(T item) => throw null!;
+
+        public void PushRange(T[] items) => throw null!;
+
+        public void PushRange(T[] items, int startIndex, int count) => throw null!;
+
+        public T[] ToArray() => throw null!;
+
+        public bool TryPeek([MaybeNullWhen(false)] out T result) => throw null!;
+
+        public bool TryPop([MaybeNullWhen(false)] out T result) => throw null!;
+
+        public int TryPopRange(T[] items) => throw null!;
+
+        public int TryPopRange(T[] items, int startIndex, int count) => throw null!;
+
+        void ICollection.CopyTo(Array array, int index) => throw null!;
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator() => throw null!;
+
+        IEnumerator IEnumerable.GetEnumerator() => throw null!;
+
+        bool IProducerConsumerCollection<T>.TryAdd(T item) => throw null!;
+
+        bool IProducerConsumerCollection<T>.TryTake([MaybeNullWhen(false)] out T item) => throw null!;
+    }
+}
diff --git a/TunnelVisionLabs.Collections.Trees.Experimental/PublicAPI.Unshipped.txt b/TunnelVisionLabs.Collections.Trees.Experimental/PublicAPI.Unshipped.txt
index 7dc5c58..4bfb79e 100644
--- a/TunnelVisionLabs.Collections.Trees.Experimental/PublicAPI.Unshipped.txt
+++ b/TunnelVisionLabs.Collections.Trees.Experimental/PublicAPI.Unshipped.txt
@@ -1 +1,117 @@
 #nullable enable
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.Add(T item) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.Clear() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.ConcurrentTreeBag() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.ConcurrentTreeBag(System.Collections.Generic.IEnumerable<T>! collection) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.CopyTo(T[]! array, int index) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.Count.get -> int
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.Enumerator
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.Enumerator.Current.get -> T
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.Enumerator.Dispose() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.Enumerator.Enumerator() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.Enumerator.MoveNext() -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.Enumerator.Reset() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.GetEnumerator() -> TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.Enumerator
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.IsEmpty.get -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.ToArray() -> T[]!
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.TryPeek(out T result) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeBag<T>.TryTake(out T result) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.AddOrUpdate(TKey key, System.Func<TKey, TValue>! addValueFactory, System.Func<TKey, TValue, TValue>! updateValueFactory) -> TValue
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.AddOrUpdate(TKey key, TValue addValue, System.Func<TKey, TValue, TValue>! updateValueFactory) -> TValue
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.AddOrUpdate<TArg>(TKey key, System.Func<TKey, TArg, TValue>! addValueFactory, System.Func<TKey, TValue, TArg, TValue>! updateValueFactory, TArg factoryArgument) -> TValue
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.Clear() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ConcurrentTreeDictionary() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ConcurrentTreeDictionary(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! collection) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ConcurrentTreeDictionary(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! collection, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ConcurrentTreeDictionary(System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ConcurrentTreeDictionary(int concurrencyLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! collection, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ConcurrentTreeDictionary(int concurrencyLevel, int capacity) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ConcurrentTreeDictionary(int concurrencyLevel, int capacity, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ContainsKey(TKey key) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.Count.get -> int
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.Enumerator
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.Enumerator.Current.get -> System.Collections.Generic.KeyValuePair<TKey, TValue>
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.Enumerator.Dispose() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.Enumerator.Enumerator() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.Enumerator.MoveNext() -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.Enumerator.Reset() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.GetEnumerator() -> TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.Enumerator
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.GetOrAdd(TKey key, System.Func<TKey, TValue>! valueFactory) -> TValue
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.GetOrAdd(TKey key, TValue value) -> TValue
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.GetOrAdd<TArg>(TKey key, System.Func<TKey, TArg, TValue>! valueFactory, TArg factoryArgument) -> TValue
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.IsEmpty.get -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.Clear() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.Contains(TKey item) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.Count.get -> int
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.Enumerator
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.Enumerator.Current.get -> TKey
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.Enumerator.Dispose() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.Enumerator.Enumerator() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.Enumerator.MoveNext() -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.Enumerator.Reset() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.GetEnumerator() -> TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.Enumerator
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.KeyCollection() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection.Remove(TKey item) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.Keys.get -> TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.KeyCollection
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ToArray() -> System.Collections.Generic.KeyValuePair<TKey, TValue>[]!
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.TryAdd(TKey key, TValue value) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.TryGetValue(TKey key, out TValue value) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.TryRemove(TKey key, out TValue value) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.TryUpdate(TKey key, TValue newValue, TValue comparisonValue) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection.Contains(TValue item) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection.Count.get -> int
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection.Enumerator
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection.Enumerator.Current.get -> TValue
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection.Enumerator.Dispose() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection.Enumerator.Enumerator() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection.Enumerator.MoveNext() -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection.Enumerator.Reset() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection.GetEnumerator() -> TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection.Enumerator
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection.ValueCollection() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.Values.get -> TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.ValueCollection
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.this[TKey key].get -> TValue
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeDictionary<TKey, TValue>.this[TKey key].set -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.Clear() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.ConcurrentTreeQueue() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.ConcurrentTreeQueue(System.Collections.Generic.IEnumerable<T>! collection) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.CopyTo(T[]! array, int index) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.Count.get -> int
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.Enqueue(T item) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.Enumerator
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.Enumerator.Current.get -> T
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.Enumerator.Dispose() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.Enumerator.Enumerator() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.Enumerator.MoveNext() -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.Enumerator.Reset() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.GetEnumerator() -> TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.Enumerator
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.IsEmpty.get -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.ToArray() -> T[]!
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.TryDequeue(out T result) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeQueue<T>.TryPeek(out T result) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.Clear() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.ConcurrentTreeStack() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.ConcurrentTreeStack(System.Collections.Generic.IEnumerable<T>! collection) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.CopyTo(T[]! array, int index) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.Count.get -> int
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.Enumerator
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.Enumerator.Current.get -> T
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.Enumerator.Dispose() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.Enumerator.Enumerator() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.Enumerator.MoveNext() -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.Enumerator.Reset() -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.GetEnumerator() -> TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.Enumerator
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.IsEmpty.get -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.Push(T item) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.PushRange(T[]! items) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.PushRange(T[]! items, int startIndex, int count) -> void
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.ToArray() -> T[]!
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.TryPeek(out T result) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.TryPop(out T result) -> bool
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.TryPopRange(T[]! items) -> int
+TunnelVisionLabs.Collections.Trees.Concurrent.ConcurrentTreeStack<T>.TryPopRange(T[]! items, int startIndex, int count) -> int