Update README.md

Added SpotSymbolCatalog to Shared ISpotSymbolRestClient interface
Added FuturesSymbolCatalog to Shared IFuturesSymbolRestClient interface
Added BaseAssetType, BaseAssetSubType, QuoteAssetType and QuoteAssetSubType to GetSymbolsRequest model
Added DisplayName to SharedSpotSymbol and SharedFuturesSymbol models
Added BaseAssetType, BaseAssetSubType, QuoteAssetType and QuoteAssetSubType to SharedSpotSymbol and SharedFuturesSymbol models
Added IsStableCoin, IsCommodity and IsEquity helper methods to LibraryHelpers

.cursor/rules/cryptoexchange-net.mdc

@@ -30,6 +30,18 @@ var ticker = await binance.GetSpotTickerAsync(new GetTickerRequest(symbol));
 
 `SharedSymbol(TradingMode.Spot, "BTC", "USDT")` is portable. Each library translates to its native format internally. Don't pass raw strings like `"BTCUSDT"` to shared methods.
 
+## Symbol metadata and catalogs
+
+In 12.2.0, `SharedSpotSymbol` and `SharedFuturesSymbol` include `DisplayName` and base/quote asset classification through `SharedAssetType` (`Crypto`, `Fiat`, `TradFi`) and `SharedAssetSubType` (`StableCoin`, `Equity`, `Commodity`). Pass the matching base/quote filters to `GetSymbolsRequest` when discovery should return only a class of markets.
+
+After calling `GetSpotSymbolsAsync`, `ISpotSymbolRestClient.SpotSymbolCatalog` maps asset and symbol names to shared metadata. `IFuturesSymbolRestClient.FuturesSymbolCatalog` works the same way after `GetFuturesSymbolsAsync`. Treat either property as unavailable before its corresponding request has populated the cache.
+
+When implementing an exchange library, use `LibraryHelpers.IsStableCoin`, `IsCommodity`, and `IsEquity` only as best-effort classifiers and supply exchange-specific additions where needed.
+
+## Shared market-data quantities
+
+In 12.4.0, use `SharedOrderQuantity`-valued `Volumes` on shared spot/futures tickers and klines, and `Quantities` on shared trades. The scalar `Volume`, `QuoteVolume`, and `Quantity` members are obsolete.
+
 ## Result pattern
 
 REST methods return `HttpResult<T>` and websocket subscription methods return `WebSocketResult<UpdateSubscription>`. Always check `.Success`. `.Exchange` property identifies which exchange responded — useful for logging.

.github/copilot-instructions.md

@@ -24,6 +24,16 @@ var ticker = await binance.GetSpotTickerAsync(new GetTickerRequest(symbol));
 
 Same code works on every exchange that implements the interface. Use `Task.WhenAll` for concurrent multi-exchange calls.
 
+## Shared symbol metadata
+
+CryptoExchange.Net 12.2.0 classifies the base and quote sides of `SharedSpotSymbol` and `SharedFuturesSymbol` with `SharedAssetType` (`Crypto`, `Fiat`, `TradFi`) and optional `SharedAssetSubType` (`StableCoin`, `Equity`, `Commodity`). The models also expose `DisplayName`. Use the corresponding base/quote fields on `GetSymbolsRequest` to filter symbol discovery.
+
+`ISpotSymbolRestClient.SpotSymbolCatalog` is populated by `GetSpotSymbolsAsync`; `IFuturesSymbolRestClient.FuturesSymbolCatalog` is populated by `GetFuturesSymbolsAsync`. Do not assume a catalog is available before that request. For exchange-library implementations, `LibraryHelpers.IsStableCoin`, `IsCommodity`, and `IsEquity` offer best-effort classification and can be extended with exchange-specific values.
+
+## Shared market-data quantities
+
+CryptoExchange.Net 12.4.0 uses `SharedOrderQuantity` for market-data quantities. Prefer `Volumes` on `SharedSpotTicker`, `SharedFuturesTicker`, and `SharedKline`, and `Quantities` on `SharedTrade`; the scalar `Volume`, `QuoteVolume`, and `Quantity` members are obsolete.
+
 ## Single-exchange code uses the exchange's own client
 
 For Binance-only code, use `BinanceRestClient` directly (see Binance.Net repo `AGENTS.md`). SharedApis is for portability — use it when you need that.

AGENTS.md

@@ -67,6 +67,28 @@ var btcusdtPerp = new SharedSymbol(TradingMode.PerpetualLinear, "BTC", "USDT");
 
 For exchanges that use exotic asset names, see the AssetAliases configuration.
 
+## Symbol Metadata and Asset Classification
+
+Since CryptoExchange.Net 12.2.0, shared symbol responses describe both sides of a market with `BaseAssetType`, `BaseAssetSubType`, `QuoteAssetType`, and `QuoteAssetSubType`. `SharedAssetType` distinguishes `Crypto`, `Fiat`, and `TradFi`; `SharedAssetSubType` distinguishes `StableCoin`, `Equity`, and `Commodity`. `SharedSpotSymbol` and `SharedFuturesSymbol` also expose `DisplayName`.
+
+The same fields on `GetSymbolsRequest` filter spot or futures symbol discovery:
+
+```csharp
+var request = new GetSymbolsRequest(
+    baseAssetType: SharedAssetType.Crypto,
+    quoteAssetSubType: SharedAssetSubType.StableCoin);
+
+var result = await symbolClient.GetSpotSymbolsAsync(request);
+```
+
+After calling `GetSpotSymbolsAsync` or `GetFuturesSymbolsAsync`, use the client's `SpotSymbolCatalog` or `FuturesSymbolCatalog` to look up normalized asset and symbol metadata by name. The catalog is unavailable until the corresponding symbol request has populated the cache.
+
+For exchange-library implementations, `LibraryHelpers.IsStableCoin`, `IsCommodity`, and `IsEquity` provide best-effort classification of known assets and accept exchange-specific additions. These helpers are heuristics, not an exhaustive source of truth.
+
+## Shared Market-Data Quantities
+
+Since CryptoExchange.Net 12.4.0, shared market-data models use `SharedOrderQuantity` so base-asset, quote-asset, and contract quantities remain explicit. Read `SharedSpotTicker.Volumes`, `SharedFuturesTicker.Volumes`, and `SharedKline.Volumes`; read `SharedTrade.Quantities`. The former scalar `Volume`, `QuoteVolume`, and `Quantity` members are obsolete.
+
 ## Available Shared Interfaces
 
 **REST:**

CryptoExchange.Net.UnitTests/AsyncResetEventTests.cs

@@ -91,28 +91,25 @@ namespace CryptoExchange.Net.UnitTests
             var evnt = new AsyncResetEvent(false, true);
 
             var waiters = new List<Task<bool>>();
-            for(var i = 0; i < 10; i++)
+            for (var i = 0; i < 10; i++)
             {
                 waiters.Add(evnt.WaitAsync());
             }
 
-            List<bool>? results = null;
-            var resultsWaiter = Task.Run(async () =>
-            {
-                await Task.WhenAll(waiters);
-                results = waiters.Select(w => w.Result).ToList();
-            });
+            var remaining = waiters.ToList();
 
-            for(var i = 1; i <= 10; i++)
+            for (var i = 0; i < 10; i++)
             {
                 evnt.Set();
-                await Task.Delay(1); // Wait for the continuation.
-                Assert.That(10 - i == waiters.Count(w => w.Status != TaskStatus.RanToCompletion));
+
+                var completed = await Task.WhenAny(remaining);
+                Assert.That(await completed, Is.True);
+
+                remaining.Remove(completed);
+                Assert.That(remaining.Count(w => w.IsCompleted), Is.Zero);
             }
 
-            await resultsWaiter;
-
-            Assert.That(10 == results?.Count(r => r));
+            Assert.That(remaining, Is.Empty);
         }
 
         [Test]

CryptoExchange.Net.UnitTests/ClientTests/SocketClientTests.cs

@@ -138,6 +138,68 @@ namespace CryptoExchange.Net.UnitTests.ClientTests
             Assert.That(socket2.Connected == false);
         }
 
+        [TestCase()]
+        public async Task BatchedSubscription_Should_NotExceedIndividualCombineTarget()
+        {
+            // arrange
+            var client = new TestSocketClient(options =>
+            {
+                options.SocketSubscriptionsCombineTarget = 10;
+                options.SocketIndividualSubscriptionCombineTarget = 10;
+            });
+            TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+
+            // act
+            await client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x => { }, false, default, individualSubscriptionCount: 6);
+            TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+            await client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x => { }, false, default, individualSubscriptionCount: 6);
+
+            // assert
+            Assert.That(client.ApiClient1._socketConnections.Count == 2);
+            Assert.That(client.ApiClient1._socketConnections.Values.All(connection => connection.Subscriptions.Sum(subscription => subscription.IndividualSubscriptionCount) <= 10));
+        }
+
+        [TestCase()]
+        public async Task BatchedSubscription_FullIndividualConnection_Should_NotPreventEligibleConnectionReuse()
+        {
+            // arrange
+            var client = new TestSocketClient(options =>
+            {
+                options.SocketSubscriptionsCombineTarget = 5;
+                options.SocketIndividualSubscriptionCombineTarget = 10;
+            });
+            TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+            await client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x => { }, false, default);
+            await client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x => { }, false, default);
+
+            TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+            await client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x => { }, false, default, individualSubscriptionCount: 10);
+
+            TestHelpers.ConfigureSocketClient(client, "wss://localhost");
+
+            // act
+            await client.ApiClient1.SubscribeToUpdatesAsync<TestObject>(x => { }, false, default);
+
+            // assert
+            Assert.That(
+                client.ApiClient1._socketConnections.Count,
+                Is.EqualTo(2),
+                "The eligible connection should be reused instead of opening a new connection after selecting a full individual-subscription connection");
+
+            var fullConnection = client.ApiClient1._socketConnections.Values
+                .Single(connection => connection.Subscriptions.Sum(subscription => subscription.IndividualSubscriptionCount) == 10);
+            Assert.That(
+                fullConnection.UserSubscriptionCount,
+                Is.EqualTo(1),
+                "The full connection should not receive the normal subscription");
+
+            var eligibleConnection = client.ApiClient1._socketConnections.Values.Single(connection => connection != fullConnection);
+            Assert.That(
+                eligibleConnection.UserSubscriptionCount,
+                Is.EqualTo(3),
+                "The existing eligible connection should receive the normal subscription");
+        }
+
         [TestCase()]
         public async Task ErrorResponse_ShouldNot_ConfirmSubscription()
         {

CryptoExchange.Net.UnitTests/ConverterTests/BoolConverterTests.cs

@@ -31,7 +31,7 @@ namespace CryptoExchange.Net.UnitTests.ConverterTests
         [TestCase(-1, false)]
         public void TestBoolConverterInts(int value, bool? expected)
         {
-            var val = value == null ? "null" : $"{value}";
+            var val = $"{value}";
             var output = JsonSerializer.Deserialize<STJBoolObject>($"{{ \"Value\": {val} }}", SerializerOptions.WithConverters(new TestSerializerContext()));
             Assert.That(output!.Value == expected);
         }

CryptoExchange.Net.UnitTests/ConverterTests/DateTimeConverterTests.cs

@@ -15,6 +15,7 @@ namespace CryptoExchange.Net.UnitTests.ConverterTests
         [TestCase("1620777600000")]
         [TestCase("2021-05-12T00:00:00.000Z")]
         [TestCase("2021-05-12T00:00:00.000000000Z")]
+        [TestCase("2021-05-12 00:00:00.000000+00:00:00")]
         [TestCase("0.000000", true)]
         [TestCase("0", true)]
         [TestCase("", true)]

CryptoExchange.Net.UnitTests/Implementations/TestSocketApiClient.cs

@@ -36,9 +36,13 @@ namespace CryptoExchange.Net.UnitTests.Implementations
         protected override TestAuthenticationProvider CreateAuthenticationProvider(TestCredentials credentials) =>
             new TestAuthenticationProvider(credentials);
 
-        public async Task<WebSocketResult<UpdateSubscription>> SubscribeToUpdatesAsync<T>(Action<DataEvent<T>> handler, bool subQuery, CancellationToken ct)
+        public async Task<WebSocketResult<UpdateSubscription>> SubscribeToUpdatesAsync<T>(Action<DataEvent<T>> handler, bool subQuery, CancellationToken ct, int individualSubscriptionCount = 1)
         {
-            return await base.SubscribeAsync(new TestSubscription<T>(_logger, handler, subQuery, false), ct);
+            var subscription = new TestSubscription<T>(_logger, handler, subQuery, false)
+            {
+                IndividualSubscriptionCount = individualSubscriptionCount
+            };
+            return await base.SubscribeAsync(subscription, ct);
         }
     }
 }

CryptoExchange.Net.UnitTests/ManualUpdateSubscriptionTests.cs

@@ -0,0 +1,136 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
+using CryptoExchange.Net.Objects.Sockets;
+using CryptoExchange.Net.Sockets.Default;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.UnitTests
+{
+    [TestFixture]
+    public class ManualUpdateSubscriptionTests
+    {
+        [Test]
+        public void Constructor_Should_CreateSubscribedVirtualSubscription()
+        {
+            var controller = new ManualUpdateSubscription(socketId: 12);
+
+            Assert.That(controller.Subscription.SocketId, Is.EqualTo(12));
+            Assert.That(controller.Subscription.Id, Is.GreaterThan(0));
+            Assert.That(controller.Subscription.SocketStatus, Is.EqualTo(SocketStatus.Connected));
+            Assert.That(controller.Subscription.SubscriptionStatus, Is.EqualTo(SubscriptionStatus.Subscribed));
+            Assert.That(controller.Subscription.LastReceiveTime, Is.Null);
+        }
+
+        [Test]
+        public void StateChanges_Should_BeVisibleOnSubscription()
+        {
+            var controller = new ManualUpdateSubscription();
+            var timestamp = new DateTime(2026, 8, 5, 12, 0, 0, DateTimeKind.Utc);
+            var statuses = new List<SubscriptionStatus>();
+            controller.Subscription.SubscriptionStatusChanged += statuses.Add;
+
+            controller.SetLastReceiveTime(timestamp);
+            controller.SetSocketStatus(SocketStatus.Reconnecting);
+            controller.SetSubscriptionStatus(SubscriptionStatus.Subscribing);
+            controller.SetSubscriptionStatus(SubscriptionStatus.Subscribed);
+
+            Assert.That(controller.Subscription.LastReceiveTime, Is.EqualTo(timestamp));
+            Assert.That(controller.Subscription.SocketStatus, Is.EqualTo(SocketStatus.Reconnecting));
+            Assert.That(controller.Subscription.SubscriptionStatus, Is.EqualTo(SubscriptionStatus.Subscribed));
+            Assert.That(statuses, Is.EqualTo(new[]
+            {
+                SubscriptionStatus.Subscribing,
+                SubscriptionStatus.Subscribed
+            }));
+        }
+
+        [Test]
+        public void LifecycleMethods_Should_InvokeSubscriptionEvents()
+        {
+            var controller = new ManualUpdateSubscription();
+            var error = new ServerError("Test error", ErrorInfo.Unknown);
+            var exception = new InvalidOperationException("Test exception");
+            var disconnectedPeriod = TimeSpan.FromMinutes(2);
+            var lost = 0;
+            var restored = TimeSpan.Zero;
+            Error? resubscribeError = null;
+            var paused = 0;
+            var unpaused = 0;
+            Exception? receivedException = null;
+
+            controller.Subscription.ConnectionLost += () => lost++;
+            controller.Subscription.ConnectionRestored += x => restored = x;
+            controller.Subscription.ResubscribingFailed += x => resubscribeError = x;
+            controller.Subscription.ActivityPaused += () => paused++;
+            controller.Subscription.ActivityUnpaused += () => unpaused++;
+            controller.Subscription.Exception += x => receivedException = x;
+
+            controller.InvokeConnectionLost();
+            controller.InvokeConnectionRestored(disconnectedPeriod);
+            controller.InvokeResubscribingFailed(error);
+            controller.InvokeActivityPaused();
+            controller.InvokeActivityUnpaused();
+            controller.InvokeException(exception);
+
+            Assert.That(lost, Is.EqualTo(1));
+            Assert.That(restored, Is.EqualTo(disconnectedPeriod));
+            Assert.That(resubscribeError, Is.SameAs(error));
+            Assert.That(paused, Is.EqualTo(1));
+            Assert.That(unpaused, Is.EqualTo(1));
+            Assert.That(receivedException, Is.SameAs(exception));
+        }
+
+        [Test]
+        public void InvokeConnectionClosed_Should_CloseAndOnlyInvokeOnce()
+        {
+            var controller = new ManualUpdateSubscription();
+            var closed = 0;
+            controller.Subscription.ConnectionClosed += () => closed++;
+
+            controller.InvokeConnectionClosed();
+            controller.InvokeConnectionClosed();
+
+            Assert.That(closed, Is.EqualTo(1));
+            Assert.That(controller.Subscription.SocketStatus, Is.EqualTo(SocketStatus.Closed));
+            Assert.That(controller.Subscription.SubscriptionStatus, Is.EqualTo(SubscriptionStatus.Closed));
+        }
+
+        [Test]
+        public async Task SubscriptionOperations_Should_InvokeCallbacks()
+        {
+            var closes = 0;
+            var reconnects = 0;
+            var resubscribes = 0;
+            var controller = new ManualUpdateSubscription(
+                closeAsync: () =>
+                {
+                    closes++;
+                    return Task.CompletedTask;
+                },
+                reconnectAsync: () =>
+                {
+                    reconnects++;
+                    return Task.CompletedTask;
+                },
+                resubscribeAsync: () =>
+                {
+                    resubscribes++;
+                    return Task.FromResult(CallResult.Ok());
+                });
+
+            await controller.Subscription.ReconnectAsync();
+            var resubscribeResult = await controller.Subscription.ResubscribeAsync();
+            await controller.Subscription.CloseAsync();
+            await controller.Subscription.CloseAsync();
+
+            Assert.That(reconnects, Is.EqualTo(1));
+            Assert.That(resubscribes, Is.EqualTo(1));
+            Assert.That(resubscribeResult.Success, Is.True);
+            Assert.That(closes, Is.EqualTo(1));
+            Assert.That(controller.Subscription.SubscriptionStatus, Is.EqualTo(SubscriptionStatus.Closed));
+        }
+    }
+}

CryptoExchange.Net.UnitTests/SocketRoutingTests/RoutingTableTests.cs

@@ -156,8 +156,9 @@ namespace CryptoExchange.Net.UnitTests.SocketRoutingTests
                 MessageRouter = messageRouter;
             }
 
+#pragma warning disable CS0067 // The event is never used, but it's required by the interface
             public event Action? OnMessageRouterUpdated;
-
+#pragma warning restore CS0067
             public bool Handle(string typeIdentifier, string? topicFilter, SocketConnection socketConnection, DateTime receiveTime, string? originalData, object result)
             {
                 return true;

CryptoExchange.Net/Clients/SocketApiClient.cs

@@ -625,6 +625,21 @@ namespace CryptoExchange.Net.Clients
             return Task.FromResult(CallResult.Ok());
         }
 
+        /// <summary>
+        /// Whether the connection can be used for a new subscription or query with the provided parameters
+        /// </summary>
+        /// <param name="connection">The connection to check</param>
+        /// <param name="address">The address set by the request</param>
+        /// <param name="authenticated">Whether the request needs an authenticated connection</param>
+        /// <param name="topic">Topic of the request</param>
+        /// <returns>True if connection can be used</returns>
+        protected virtual bool ConnectionCanBeUsedFor(SocketConnection connection, string address, bool authenticated, string? topic = null)
+        {
+            return connection.ConnectionUriString.Equals(address.TrimEnd('/'), StringComparison.Ordinal)
+                && connection.ApiClient.ClientName.Equals(ClientName, StringComparison.Ordinal)
+                && (AllowTopicsOnTheSameConnection || !connection.Topics.Contains(topic));
+        }
+
         /// <summary>
         /// Gets a connection for a new subscription or query. Can be an existing if there are open position or a new one.
         /// </summary>
@@ -643,10 +658,7 @@ namespace CryptoExchange.Net.Clients
             string? topic = null,
             int individualSubscriptionCount = 1)
         {
-            var socketQuery = _socketConnections.Where(s => s.Value.ConnectionUriString.Equals(address.TrimEnd('/'), StringComparison.Ordinal)
-                                                         && s.Value.ApiClient.ClientName.Equals(ClientName, StringComparison.Ordinal)
-                                                         && (AllowTopicsOnTheSameConnection || !s.Value.Topics.Contains(topic)))
-                                                .Select(x => x.Value); // Don't ToList this so the query is executed again when called
+            var socketQuery = _socketConnections.Where(s => ConnectionCanBeUsedFor(s.Value, address, authenticated, topic)).Select(x => x.Value); // Don't ToList this so the query is executed again when called
 
             // If all current socket connections are reconnecting or resubscribing wait for that to finish as we can probably use the existing connection
             var delayStart = DateTime.UtcNow;
@@ -679,45 +691,26 @@ namespace CryptoExchange.Net.Clients
                                                 && (s.Authenticated == authenticated || !authenticated)
                                                 && s.Connected).ToList();
 
-            SocketConnection? connection;
-            if (!dedicatedRequestConnection)
-            {
-                connection = socketQuery
-                    .Where(s => !s.DedicatedRequestConnection.IsDedicatedRequestConnection)
-                    .OrderBy(s => s.UserSubscriptionCount)
-                    .FirstOrDefault();
-            }
-            else
+            bool maxConnectionsReached = _socketConnections.Count >= (ApiOptions.MaxSocketConnections ?? ClientOptions.MaxSocketConnections);
+            SocketConnection? connection = null;
+            if (dedicatedRequestConnection)
             {
                 connection = socketQuery.Where(s => s.DedicatedRequestConnection.IsDedicatedRequestConnection).FirstOrDefault();
                 if (connection != null && !connection.DedicatedRequestConnection.Authenticated)
                     // Mark dedicated request connection as authenticated if the request is authenticated
                     connection.DedicatedRequestConnection.Authenticated = authenticated;
-
-                if (connection == null)
-                    // Fall back to an existing connection if there is no dedicated request connection available
-                    connection = socketQuery.OrderBy(s => s.UserSubscriptionCount).FirstOrDefault();
             }
 
-            bool maxConnectionsReached = _socketConnections.Count >= (ApiOptions.MaxSocketConnections ?? ClientOptions.MaxSocketConnections);
+            if (connection == null)
+                // Use an eligible non-dedicated connection for subscriptions, or as fallback when no dedicated request connection is available
+                connection = socketQuery
+                    .Where(s => !s.DedicatedRequestConnection.IsDedicatedRequestConnection)
+                    .Where(s => IsConnectionEligible(s, individualSubscriptionCount, maxConnectionsReached))
+                    .OrderBy(s => s.UserSubscriptionCount)
+                    .FirstOrDefault();
+
             if (connection != null)
-            {
-                bool lessThanBatchSubCombineTarget = connection.UserSubscriptionCount < ClientOptions.SocketSubscriptionsCombineTarget;
-                bool lessThanIndividualSubCombineTarget = connection.Subscriptions.Sum(x => x.IndividualSubscriptionCount) < ClientOptions.SocketIndividualSubscriptionCombineTarget;
-
-                if ((lessThanBatchSubCombineTarget && lessThanIndividualSubCombineTarget)
-                    || maxConnectionsReached) 
-                {
-                    // Use existing socket if it has less than target connections OR it has the least connections and we can't make new
-                    // If there is a max subscriptions per connection limit also only use existing if the new subscription doesn't go over the limit
-                    if (MaxIndividualSubscriptionsPerConnection == null)
-                        return CallResult.Ok(connection);
-                                        
-                    var currentCount = connection.Subscriptions.Sum(x => x.IndividualSubscriptionCount);
-                    if (currentCount + individualSubscriptionCount <= MaxIndividualSubscriptionsPerConnection)
-                        return CallResult.Ok(connection);
-                }
-            }
+                return CallResult.Ok(connection);
 
             if (maxConnectionsReached)
                 return CallResult.Fail<SocketConnection>(new InvalidOperationError("Max amount of socket connections reached"));
@@ -784,6 +777,21 @@ namespace CryptoExchange.Net.Clients
             return CallResult.Ok(socketConnection);
         }
 
+        private bool IsConnectionEligible(SocketConnection socketConnection, int individualSubscriptionCount, bool maxConnectionsReached)
+        {
+            var currentIndividualSubscriptionCount = socketConnection.Subscriptions.Sum(x => x.IndividualSubscriptionCount);
+            bool lessThanBatchSubCombineTarget = socketConnection.UserSubscriptionCount < ClientOptions.SocketSubscriptionsCombineTarget;
+            // Include the incoming batch so batched subscriptions cannot overshoot the configured socket target.
+            bool lessThanIndividualSubCombineTarget = currentIndividualSubscriptionCount + individualSubscriptionCount <= ClientOptions.SocketIndividualSubscriptionCombineTarget;
+
+            if ((!lessThanBatchSubCombineTarget || !lessThanIndividualSubCombineTarget)
+                && !maxConnectionsReached)
+                return false;
+
+            return MaxIndividualSubscriptionsPerConnection == null
+                || currentIndividualSubscriptionCount + individualSubscriptionCount <= MaxIndividualSubscriptionsPerConnection;
+        }
+
         /// <summary>
         /// Process an unhandled message
         /// </summary>

CryptoExchange.Net/Converters/SystemTextJson/DateTimeConverter.cs

@@ -198,6 +198,9 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                 return new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
             }
 
+            if (stringValue.EndsWith("+00:00:00"))
+                return DateTime.Parse(stringValue.Substring(0, stringValue.Length - 9), CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
+
             return DateTime.Parse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
         }
 

CryptoExchange.Net/Converters/SystemTextJson/MessageHandlers/JsonRestMessageHandler.cs

@@ -88,7 +88,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson.MessageHandlers
                     stream.Seek(0, SeekOrigin.Begin);
                     var written = new StreamReader(stream).ReadBlock(dataSnippet, 0, _errorResponseSnippetLimit);
                     var data = new string(dataSnippet, 0, written);
-                    errorMsg += $": {data}";
+                    errorMsg += $": {(string.IsNullOrEmpty(data) ? "(empty)" : data)}";
                     if (data.Length == _errorResponseSnippetLimit)
                         errorMsg += " (truncated)";
                 }

CryptoExchange.Net/CryptoExchange.Net.csproj

@@ -6,9 +6,9 @@
     <PackageId>CryptoExchange.Net</PackageId>
     <Authors>JKorf</Authors>
     <Description>CryptoExchange.Net is a base library which is used to implement different cryptocurrency (exchange) API's. It provides a standardized way of implementing different API's, which results in a very similar experience for users of the API implementations.</Description>
-    <PackageVersion>12.0.1</PackageVersion>
-    <AssemblyVersion>12.0.1</AssemblyVersion>
-    <FileVersion>12.0.1</FileVersion>
+    <PackageVersion>12.4.0</PackageVersion>
+    <AssemblyVersion>12.4.0</AssemblyVersion>
+    <FileVersion>12.4.0</FileVersion>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>OKX;OKX.Net;Mexc;Mexc.Net;Kucoin;Kucoin.Net;Kraken;Kraken.Net;Huobi;Huobi.Net;CoinEx;CoinEx.Net;Bybit;Bybit.Net;Bitget;Bitget.Net;Bitfinex;Bitfinex.Net;Binance;Binance.Net;CryptoCurrency;CryptoCurrency Exchange;CryptoExchange.Net</PackageTags>
     <RepositoryType>git</RepositoryType>

CryptoExchange.Net/ExchangeSymbolCache.cs

@@ -33,7 +33,7 @@ namespace CryptoExchange.Net
             if (keyedCache != null && DateTime.UtcNow - keyedCache.UpdateTime < TimeSpan.FromMinutes(60))
                 return;
 
-            exchangeInfo.Set(key, new ExchangeInfo(DateTime.UtcNow, updateData.ToDictionary(x => x.Name, x => x.SharedSymbol)));
+            exchangeInfo.Set(key, new ExchangeInfo(DateTime.UtcNow, updateData.ToDictionary(x => x.Name, x => x)));
         }
 
         /// <summary>
@@ -118,6 +118,22 @@ namespace CryptoExchange.Net
             return exchangeInfo.ParseSymbol(key, symbolName);
         }
 
+        /// <summary>
+        /// Get a symbol catalog for a specific exchange(topic) and environment. Only available if <see cref="UpdateSymbolInfo(string, string, string?, SharedSpotSymbol[])"/> has been called previously.
+        /// </summary>
+        /// <param name="exchange">Exchange name</param>
+        /// <param name="topicId">Id for the provided data</param>
+        /// <param name="environmentName">Trade environment</param>
+        /// <param name="key">Additional data set identification key</param>
+        public static SharedSymbolCatalog? GetSymbolCatalog(string exchange, string topicId, string environmentName, string? key)
+        {
+            var id = topicId + environmentName;
+            if (!_symbolInfos.TryGetValue(id, out var exchangeInfo))
+                return null;
+
+            return exchangeInfo.GetSymbolCatalog(exchange, key);
+        }
+
         class ExchangeKeyedCache
         {
             private ExchangeInfo? _noKeyCache;
@@ -163,7 +179,7 @@ namespace CryptoExchange.Net
 
             public SharedSymbol? ParseSymbol(string? key, string symbolName)
             {
-                SharedSymbol? symbolInfo = null;
+                SharedSpotSymbol? symbolInfo = null;
                 if (key == null)
                 {
                     if (_noKeyCache != null)
@@ -173,7 +189,7 @@ namespace CryptoExchange.Net
 
                         return new SharedSymbol(symbolInfo.TradingMode, symbolInfo.BaseAsset, symbolInfo.QuoteAsset, symbolName)
                         {
-                            DeliverTime = symbolInfo.DeliverTime
+                            DeliverTime = (symbolInfo as SharedFuturesSymbol)?.DeliveryTime
                         };
                     }
 
@@ -183,7 +199,7 @@ namespace CryptoExchange.Net
                         {
                             return new SharedSymbol(symbolInfo.TradingMode, symbolInfo.BaseAsset, symbolInfo.QuoteAsset, symbolName)
                             {
-                                DeliverTime = symbolInfo.DeliverTime
+                                DeliverTime = (symbolInfo as SharedFuturesSymbol)?.DeliveryTime
                             };
                         }
                     }
@@ -199,7 +215,7 @@ namespace CryptoExchange.Net
                 {
                     return new SharedSymbol(symbolInfo.TradingMode, symbolInfo.BaseAsset, symbolInfo.QuoteAsset, symbolName)
                     {
-                        DeliverTime = symbolInfo.DeliverTime
+                        DeliverTime = (symbolInfo as SharedFuturesSymbol)?.DeliveryTime
                     };
                 }
 
@@ -265,7 +281,7 @@ namespace CryptoExchange.Net
                     {
                         return _noKeyCache.Symbols
                             .Where(x => x.Value.BaseAsset.Equals(baseAsset, StringComparison.InvariantCultureIgnoreCase))
-                            .Select(x => x.Value)
+                            .Select(x => x.Value.SharedSymbol)
                             .ToArray();
                     }
 
@@ -274,7 +290,7 @@ namespace CryptoExchange.Net
                     {
                         result.AddRange(cache.Symbols
                             .Where(x => x.Value.BaseAsset.Equals(baseAsset, StringComparison.InvariantCultureIgnoreCase))
-                            .Select(x => x.Value));
+                            .Select(x => x.Value.SharedSymbol));
                     }
 
                     return result.ToArray();
@@ -286,18 +302,63 @@ namespace CryptoExchange.Net
 
                 return exchangeInfo.Symbols
                     .Where(x => x.Value.BaseAsset.Equals(baseAsset, StringComparison.InvariantCultureIgnoreCase))
-                    .Select(x => x.Value)
+                    .Select(x => x.Value.SharedSymbol)
                     .ToArray();
             }
+
+            internal SharedSymbolCatalog? GetSymbolCatalog(string exchange, string? key)
+            {
+                IEnumerable<SharedSpotSymbol> cachedSymbols;
+                if (key == null)
+                {
+                    if (_noKeyCache != null)
+                        cachedSymbols = _noKeyCache.Symbols.Values;
+                    else
+                        cachedSymbols = _keyedCache.Values.SelectMany(x => x.Symbols.Values);
+                }
+                else
+                {
+                    if (!_keyedCache.TryGetValue(key, out var exchangeInfo) || exchangeInfo == null)
+                        return null;
+
+                    cachedSymbols = exchangeInfo.Symbols.Values;
+                }
+
+                var assets = new Dictionary<string, SharedAssetInfo>();
+                var symbols = new Dictionary<string, SharedSpotSymbol>();
+                foreach (var symbol in cachedSymbols)
+                {
+                    if (!assets.TryGetValue(symbol.BaseAsset, out var baseAssetInfo))
+                    {
+                        baseAssetInfo = new SharedAssetInfo(symbol.BaseAsset, symbol.BaseAssetType, symbol.BaseAssetSubType);
+                        assets.Add(symbol.BaseAsset, baseAssetInfo);
+                    }
+
+                    if (!assets.TryGetValue(symbol.QuoteAsset, out var quoteAssetInfo))
+                    {
+                        quoteAssetInfo = new SharedAssetInfo(symbol.QuoteAsset, symbol.QuoteAssetType, symbol.QuoteAssetSubType);
+                        assets.Add(symbol.QuoteAsset, quoteAssetInfo);
+                    }
+
+                    symbols.Add(symbol.Name, symbol);
+                }
+
+                return new SharedSymbolCatalog
+                {
+                    Exchange = exchange,
+                    Assets = assets,
+                    Symbols = symbols
+                };
+            }
         }
 
 
         class ExchangeInfo
         {
             public DateTime UpdateTime { get; set; }
-            public Dictionary<string, SharedSymbol> Symbols { get; set; }
+            public Dictionary<string, SharedSpotSymbol> Symbols { get; set; }
 
-            public ExchangeInfo(DateTime updateTime, Dictionary<string, SharedSymbol> symbols)
+            public ExchangeInfo(DateTime updateTime, Dictionary<string, SharedSpotSymbol> symbols)
             {
                 UpdateTime = updateTime;
                 Symbols = symbols;

CryptoExchange.Net/Interfaces/ITrackerFactory.cs

@@ -24,8 +24,9 @@ namespace CryptoExchange.Net.Interfaces
         /// <param name="interval">Kline interval</param>
         /// <param name="limit">The max amount of klines to retain</param>
         /// <param name="period">The max period the data should be retained</param>
+        /// <param name="exchangeParameters">Exchange parameters</param>
         /// <returns></returns>
-        IKlineTracker CreateKlineTracker(SharedSymbol symbol, SharedKlineInterval interval, int? limit = null, TimeSpan? period = null);
+        IKlineTracker CreateKlineTracker(SharedSymbol symbol, SharedKlineInterval interval, int? limit = null, TimeSpan? period = null, ExchangeParameters? exchangeParameters = null);
 
         /// <summary>
         /// Whether the factory supports creating a TradeTracker instance for this symbol
@@ -39,7 +40,8 @@ namespace CryptoExchange.Net.Interfaces
         /// <param name="symbol">The symbol</param>
         /// <param name="limit">The max amount of trades to retain</param>
         /// <param name="period">The max period the data should be retained</param>
+        /// <param name="exchangeParameters">Exchange parameters</param>
         /// <returns></returns>
-        ITradeTracker CreateTradeTracker(SharedSymbol symbol, int? limit = null, TimeSpan? period = null);
+        ITradeTracker CreateTradeTracker(SharedSymbol symbol, int? limit = null, TimeSpan? period = null, ExchangeParameters? exchangeParameters = null);
     }
 }

CryptoExchange.Net/LibraryHelpers.cs

@@ -4,6 +4,8 @@ using CryptoExchange.Net.Objects.Options;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
+using System.IO.Pipelines;
+using System.Linq;
 using System.Net;
 using System.Net.Http;
 
@@ -14,6 +16,61 @@ namespace CryptoExchange.Net
     /// </summary>
     public static class LibraryHelpers
     {
+        private static readonly HashSet<string> _stableCoins = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            // USD
+            "USDT", "USDC", "DAI", "FDUSD", "USDE", "TUSD", "USDP", "PYUSD", "GUSD",
+            "USDD", "LUSD", "USDJ", "SUSD", "ZUSD", "BUSD", "USTC", "USDX", "USDK",
+            "CUSD", "USD1", "USD0", "XUSD", "BFUSD", "USDS", "RLUSD", "OUSD", "USDH",
+            "APXUSD", "USDQ", "USDPT", "FIDD", "AUSD",
+            // EUR
+            "EURS", "EURC", "EURI", "EURT", "AGEUR", "CEUR", "AEUR", "EURQ", "EUROP",
+            // Other
+            "CNYT",  // CNY
+            "CREAL", "BRL1", // BRL
+            "XSGD",  // SGD
+            "GYEN",  // JPY
+            "KGST",  // KGS
+            "QCAD",  // CAD
+            "TGBP",  // GBP
+            "AUDX",  // AUD
+            "MXNB",  // MXN
+        };
+
+        private static readonly HashSet<string> _commodities = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            // Metals
+            "XAU", "XAUT", "XAG", "XPT", "XPD", "COPPER", "PAXG", "XNI", "XCU", "XAL", "GOLD", "SILVER",
+             // Energy
+            "BZ", "NATGAS", "NGAS", "CL", "XTI", "UKOIL", "USOIL", "BRENTOIL"
+        };
+
+        private static readonly HashSet<string> _stocks = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            // Top stocks, will need to update periodically
+            "AAAU", "AADR", "AAPL", "ACWI", "ACWX", "AGG", "AMD", "AMLP", "AMZN", "ARKF",
+            "ARKG", "ARKK", "ARKQ", "ARKW", "AVGO", "BA", "BABA", "BND", "BNDX", "BOTZ",
+            "CIBR", "COIN", "DIA", "DIVB", "DVY", "EEM", "EFA", "EFAV", "ESGU", "EWG",
+            "EWJ", "EWT", "EWU", "EWW", "EWY", "EWZ", "FDN", "FEZ", "GLDM", "GOOGL",
+            "HDV", "HOOD", "HYG", "IAU", "IBB", "ICLN", "IEFA", "IEMG", "IGSB", "IJH",
+            "IJR", "INTC", "ITOT", "IUSB", "IUSG", "IUSV", "IWM", "IWO", "IWR", "IYR",
+            "JETS", "JPM", "LIT", "MCHI", "META", "MGK", "MSTR", "MTUM", "MU", "NET",
+            "NFLX", "NOBL", "NVDA", "OIH", "ORCL", "PAVE", "PBW", "PLTR", "QQQ", "QQQM",
+            "SCHB", "SCHD", "SCHF", "SCHG", "SCHH", "SCHV", "SCHX", "SKHY", "SPCX", "SPCXD",
+            "SPLG", "SPY", "SPYG", "SPYV", "SQQQ", "TSLA", "TSM", "TQQQ", "USMV", "VBR",
+            "VCIT", "VCSH", "VEA", "VEU", "VGIT", "VGK", "VGT", "VHT", "VIG", "VNQ",
+            "VOO", "VOT", "VTI", "VTV", "VUG", "VXUS", "XBI", "XLC", "XLE", "XLF",
+            "XLI", "XLK", "XLP", "XLU", "XLV", "XLY", "CSCO", "UBER", "MRVL", "RKLB",
+            "COHR", "SOXL", "HD", "DIS", "CBRS", "V", "BRKB", "FLNC", "LLY", "COST",
+            "ARM", "BMNR", "NBIS", "ASML", "AAOI", "GLW", "SHLD", "BE", "QNTX", "IBM",
+            "AMAT", "NOK", "ASTS", "BBX", "SLX", "SKHYNIX", "SAMSUNG", "HYUNDAI", "NVO",
+            "IREN", "ONDS", "CRM" , "VRT", "ZEST", "BTW", "HPE", "AXTI", "BX", "CRWD",
+            "CRDO", "NOW", "ZM", "DKNG", "RIVN", "URNM", "EBAY", "ADBE", "UVXY", "RDW",
+            "CIEN","PANW", "WIN", "PAYP", "HIMS", "CRWV", "QCOM", "LITE", "DRAM", "ANTHROPIC",
+            "OPENAI", "USAR", "BILL", "SNDK", "NASDAQ100", "SPX500", "BSB", "CRCL", "STRC",
+            "MSFT", "WDC"
+        };
+
         private static ILogger? _staticLogger;
         /// <summary>
         /// Static logger
@@ -105,6 +162,67 @@ namespace CryptoExchange.Net
             return _defaultClientReferences.TryGetValue(key, out var id) ? id : throw new KeyNotFoundException($"{exchange} not found in configuration");
         }
 
+        /// <summary>
+        /// Check whether an asset is a known stablecoin. Note that this is not definitive, only large known stocks are checked
+        /// </summary>
+        /// <param name="asset">Asset name</param>
+        /// <param name="additionalStableCoins">Additional stablecoin names for the specific exchange</param>
+        public static bool IsStableCoin(string asset, params HashSet<string> additionalStableCoins)
+        {
+            if (string.IsNullOrEmpty(asset))
+                return false;
+
+            return _stableCoins.Contains(asset) || (additionalStableCoins != null && additionalStableCoins.Contains(asset, StringComparer.OrdinalIgnoreCase));
+        }
+
+        /// <summary>
+        /// Check whether an asset is a known commodity. Note that this is not definitive, only large known stocks are checked
+        /// </summary>
+        /// <param name="asset">Asset name</param>
+        /// <param name="additionalCommodities">Additional commodity names for the specific exchange</param>
+        public static bool IsCommodity(string asset, params HashSet<string> additionalCommodities)
+        {
+            if (string.IsNullOrEmpty(asset))
+                return false;
+
+            return _commodities.Contains(asset) || (additionalCommodities != null && additionalCommodities.Contains(asset, StringComparer.OrdinalIgnoreCase));
+        }
+
+        /// <summary>
+        /// Check whether an asset is a known stock. Note that this is not definitive, only large known stocks are checked
+        /// </summary>
+        /// <param name="asset">Asset name</param>
+        /// <param name="additionalStocks">Additional stock names for the specific exchange</param>
+        public static bool IsEquity(string asset, params HashSet<string> additionalStocks)
+            => IsEquity(asset, [], additionalStocks);
+
+        /// <summary>
+        /// Check whether an asset is a known stock.
+        /// </summary>
+        /// <param name="asset">Asset name</param>
+        /// <param name="potentialSuffixes">Suffixes to check, for example when `X` is a potential suffix both `TSLA` and `TSLAX` will be checked</param>
+        /// <param name="additionalStocks">Additional stock names for the specific exchange</param>
+        public static bool IsEquity(string asset, string[] potentialSuffixes, params HashSet<string> additionalStocks)
+        {
+            if (string.IsNullOrEmpty(asset))
+                return false;
+
+            if (_stocks.Contains(asset) || (additionalStocks != null && additionalStocks.Contains(asset, StringComparer.OrdinalIgnoreCase)))
+                return true;
+
+            foreach (var suffix in potentialSuffixes) 
+            {
+                if (!asset.EndsWith(suffix))
+                    continue;
+
+                var suffixAsset = asset.Substring(0, asset.Length - suffix.Length);
+                if (_stocks.Contains(suffixAsset) || (additionalStocks != null && additionalStocks.Contains(suffixAsset, StringComparer.OrdinalIgnoreCase)))
+                    return true;
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Create a new HttpMessageHandler instance
         /// </summary>  

CryptoExchange.Net/Logging/Extensions/SocketConnectionLoggingExtension.cs

@@ -180,7 +180,7 @@ namespace CryptoExchange.Net.Logging.Extensions
             _receivedMessageNotMatchedToAnyListener = LoggerMessage.Define<int, string, string, string>(
                 LogLevel.Warning,
                 new EventId(2029, "ReceivedMessageNotMatchedToAnyListener"),
-                "[Sckt {SocketId}] received message not matched to any listener. TypeIdentifier: {TypeIdentifier}, ListenId: {ListenId}, current listeners: [{ListenIds}]");
+                "[Sckt {SocketId}] received message not matched to any listener. TypeIdentifier: {TypeIdentifier}, TopicFilter: {ListenId}, registered TopicFilters for type: [{TopicFilters}]");
 
             _failedToParse = LoggerMessage.Define<int, string>(
                 LogLevel.Warning,
@@ -326,9 +326,9 @@ namespace CryptoExchange.Net.Logging.Extensions
             _sendingData(logger, socketId, requestId, data, null);
         }
 
-        public static void ReceivedMessageNotMatchedToAnyListener(this ILogger logger, int socketId, string typeIdentifier, string listenId, string listenIds)
+        public static void ReceivedMessageNotMatchedToAnyListener(this ILogger logger, int socketId, string typeIdentifier, string topicFilter, string topicFilters)
         {
-            _receivedMessageNotMatchedToAnyListener(logger, socketId, typeIdentifier, listenId, listenIds, null);
+            _receivedMessageNotMatchedToAnyListener(logger, socketId, typeIdentifier, topicFilter, topicFilters, null);
         }
 
         public static void SendingByteData(this ILogger logger, int socketId, int requestId, int length)

CryptoExchange.Net/Objects/Parameters.cs

@@ -233,7 +233,7 @@ namespace CryptoExchange.Net.Objects
         /// Add key as comma separated values
         /// </summary>
 #if NET5_0_OR_GREATER
-        public void AddCommaSeparated<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | DynamicallyAccessedMemberTypes.PublicFields)] T>(string key, IEnumerable<T> values)
+        public void AddCommaSeparated<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | DynamicallyAccessedMemberTypes.PublicFields)] T>(string key, IEnumerable<T>? values)
 #else
         public void AddCommaSeparated<T>(string key, IEnumerable<T>? values)
 #endif

CryptoExchange.Net/Objects/Results/CallResult.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Text;
 
@@ -8,8 +9,11 @@ namespace CryptoExchange.Net.Objects;
 /// <summary>
 /// Call result
 /// </summary>
+[DebuggerDisplay("{DebugView,nq}")]
 public record CallResult : ICallResult
 {
+    private string DebugView => Success ? "Success" : $"Error: {Error}";
+
     private static CallResult _successResult = new CallResult();
 
     /// <inheritdoc />

CryptoExchange.Net/Objects/Results/HttpResult.cs

@@ -1,6 +1,7 @@
 using CryptoExchange.Net.SharedApis;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Net;
 using System.Net.Http;
@@ -12,8 +13,11 @@ namespace CryptoExchange.Net.Objects;
 /// <summary>
 /// HTTP call result
 /// </summary>
+[DebuggerDisplay("{DebugView,nq}")]
 public record HttpResult : IHttpResult
 {
+    private string DebugView => $"[Req {RequestId}] " + (Success ? "Success" : $"Error: {Error}");
+
     /// <summary>
     /// Create a new success HTTP result
     /// </summary>
@@ -251,8 +255,32 @@ public record HttpResult : IHttpResult
 
 
 /// <inheritdoc />
+[DebuggerDisplay("{DebugView,nq}")]
 public record HttpResult<T> : HttpResult, IHttpResult<T>
 {
+    private string DebugView
+    {
+        get
+        {
+            var result = new StringBuilder($"[Req {RequestId}] " + (Success ? "Success" : $"Error: {Error}"));
+            if (Data != null)
+            {
+                result.Append(", ");
+                var typeName = typeof(T).Name;
+                if (Data is Array ar)
+                {
+                    result.Append($"{ar.Length} {typeName.Substring(0, typeName.Length - 2)}");
+                }
+                else
+                {
+                    result.Append(typeName);
+                }
+            }
+
+            return result.ToString();
+        }
+    } 
+
     /// <summary>
     /// ctor
     /// </summary>

CryptoExchange.Net/Objects/Results/WebSocketResult.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Text;
 
@@ -8,8 +9,11 @@ namespace CryptoExchange.Net.Objects;
 /// <summary>
 /// WebSocket call result
 /// </summary>
+[DebuggerDisplay("{DebugView,nq}")]
 public record WebSocketResult : IWebSocketResult
 {
+    private string DebugView => $"[Sckt {ConnectionId}] " + (RequestId == null ? "" : $"[Req {RequestId}] ") + (Success ? "Success" : $"Error: {Error}");
+
     /// <summary>
     /// ctor
     /// </summary>

CryptoExchange.Net/Objects/Sockets/ManualUpdateSubscription.cs

@@ -0,0 +1,209 @@
+using CryptoExchange.Net.Sockets;
+using CryptoExchange.Net.Sockets.Default;
+using CryptoExchange.Net.Sockets.Default.Routing;
+using Microsoft.Extensions.Logging.Abstractions;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CryptoExchange.Net.Objects.Sockets
+{
+    /// <summary>
+    /// Controller for an update subscription which isn't backed by a websocket connection. Can be used for testing.
+    /// </summary>
+    public class ManualUpdateSubscription
+    {
+        private readonly Func<Task> _closeAsync;
+        private readonly Func<Task> _reconnectAsync;
+        private readonly Func<Task<CallResult>> _resubscribeAsync;
+        private readonly ManualSubscription _manualSubscription;
+        private int _closedEventInvoked;
+
+        /// <summary>
+        /// The update subscription
+        /// </summary>
+        public UpdateSubscription Subscription { get; }
+
+        /// <summary>
+        /// The virtual socket id
+        /// </summary>
+        public int SocketId { get; }
+
+        /// <summary>
+        /// The last timestamp anything was received by the subscription
+        /// </summary>
+        public DateTime? LastReceiveTime { get; private set; }
+
+        /// <summary>
+        /// The current virtual websocket status
+        /// </summary>
+        public SocketStatus SocketStatus { get; private set; }
+
+        /// <summary>
+        /// Create a manually controlled update subscription
+        /// </summary>
+        /// <param name="socketId">The virtual socket id</param>
+        /// <param name="closeAsync">Callback when the subscription is closed</param>
+        /// <param name="reconnectAsync">Callback when a reconnect is requested</param>
+        /// <param name="resubscribeAsync">Callback when a resubscribe is requested</param>
+        public ManualUpdateSubscription(
+            int socketId = 0,
+            Func<Task>? closeAsync = null,
+            Func<Task>? reconnectAsync = null,
+            Func<Task<CallResult>>? resubscribeAsync = null)
+        {
+            SocketId = socketId;
+            SocketStatus = SocketStatus.Connected;
+            _closeAsync = closeAsync ?? (() => Task.CompletedTask);
+            _reconnectAsync = reconnectAsync ?? (() => Task.CompletedTask);
+            _resubscribeAsync = resubscribeAsync ?? (() => Task.FromResult(CallResult.Ok()));
+
+            _manualSubscription = new ManualSubscription();
+            _manualSubscription.Status = SubscriptionStatus.Subscribed;
+            Subscription = new UpdateSubscription(this, _manualSubscription);
+        }
+
+        /// <summary>
+        /// Set the last timestamp anything was received by the subscription
+        /// </summary>
+        /// <param name="timestamp">The receive timestamp</param>
+        public void SetLastReceiveTime(DateTime? timestamp)
+        {
+            LastReceiveTime = timestamp;
+        }
+
+        /// <summary>
+        /// Set the virtual websocket status
+        /// </summary>
+        /// <param name="status">The status</param>
+        public void SetSocketStatus(SocketStatus status)
+        {
+            SocketStatus = status;
+        }
+
+        /// <summary>
+        /// Set the subscription status
+        /// </summary>
+        /// <param name="status">The status</param>
+        public void SetSubscriptionStatus(SubscriptionStatus status)
+        {
+            _manualSubscription.Status = status;
+        }
+
+        /// <summary>
+        /// Invoke the connection lost event
+        /// </summary>
+        public void InvokeConnectionLost()
+        {
+            Subscription.HandleConnectionLostEvent();
+        }
+
+        /// <summary>
+        /// Invoke the connection restored event
+        /// </summary>
+        /// <param name="disconnectedPeriod">The period the connection was disconnected</param>
+        public void InvokeConnectionRestored(TimeSpan disconnectedPeriod)
+        {
+            Subscription.HandleConnectionRestoredEvent(disconnectedPeriod);
+        }
+
+        /// <summary>
+        /// Invoke the connection closed event
+        /// </summary>
+        public void InvokeConnectionClosed()
+        {
+            if (Interlocked.Exchange(ref _closedEventInvoked, 1) != 0)
+                return;
+
+            SocketStatus = SocketStatus.Closed;
+            _manualSubscription.Status = SubscriptionStatus.Closed;
+            Subscription.HandleConnectionClosedEvent();
+        }
+
+        /// <summary>
+        /// Invoke the resubscribing failed event
+        /// </summary>
+        /// <param name="error">The resubscribe error</param>
+        public void InvokeResubscribingFailed(Error error)
+        {
+            if (error == null)
+                throw new ArgumentNullException(nameof(error));
+
+            Subscription.HandleResubscribeFailedEvent(error);
+        }
+
+        /// <summary>
+        /// Invoke the activity paused event
+        /// </summary>
+        public void InvokeActivityPaused()
+        {
+            Subscription.HandlePausedEvent();
+        }
+
+        /// <summary>
+        /// Invoke the activity unpaused event
+        /// </summary>
+        public void InvokeActivityUnpaused()
+        {
+            Subscription.HandleUnpausedEvent();
+        }
+
+        /// <summary>
+        /// Invoke the exception event
+        /// </summary>
+        /// <param name="exception">The exception</param>
+        public void InvokeException(Exception exception)
+        {
+            if (exception == null)
+                throw new ArgumentNullException(nameof(exception));
+
+            _manualSubscription.InvokeExceptionHandler(exception);
+        }
+
+        internal async Task CloseAsync()
+        {
+            if (_manualSubscription.Status == SubscriptionStatus.Closed
+                || _manualSubscription.Status == SubscriptionStatus.Closing)
+                return;
+
+            _manualSubscription.Status = SubscriptionStatus.Closing;
+            try
+            {
+                await _closeAsync().ConfigureAwait(false);
+            }
+            finally
+            {
+                _manualSubscription.Status = SubscriptionStatus.Closed;
+            }
+        }
+
+        internal Task ReconnectAsync()
+        {
+            return _reconnectAsync();
+        }
+
+        internal Task<CallResult> ResubscribeAsync()
+        {
+            return _resubscribeAsync();
+        }
+
+        private class ManualSubscription : Subscription
+        {
+            public ManualSubscription()
+                : base(NullLogger.Instance, false)
+            {
+                MessageRouter = MessageRouter.Create();
+            }
+
+            protected override Query? GetSubQuery(SocketConnection connection)
+            {
+                return null;
+            }
+
+            protected override Query? GetUnsubQuery(SocketConnection connection)
+            {
+                return null;
+            }
+        }
+    }
+}

CryptoExchange.Net/Objects/Sockets/UpdateSubscription.cs

@@ -12,7 +12,8 @@ namespace CryptoExchange.Net.Objects.Sockets
     /// </summary>
     public class UpdateSubscription
     {
-        private readonly SocketConnection _connection;
+        private readonly SocketConnection? _connection;
+        private readonly ManualUpdateSubscription? _manualSubscription;
         internal readonly Subscription _subscription;
 
 #if NET9_0_OR_GREATER
@@ -102,7 +103,7 @@ namespace CryptoExchange.Net.Objects.Sockets
         /// <summary>
         /// The id of the socket
         /// </summary>
-        public int SocketId => _connection.SocketId;
+        public int SocketId => _connection?.SocketId ?? _manualSubscription!.SocketId;
 
         /// <summary>
         /// The id of the subscription
@@ -112,12 +113,12 @@ namespace CryptoExchange.Net.Objects.Sockets
         /// <summary>
         /// The last timestamp anything was received from the server
         /// </summary>
-        public DateTime? LastReceiveTime => _connection.LastReceiveTime;
+        public DateTime? LastReceiveTime => _connection?.LastReceiveTime ?? _manualSubscription!.LastReceiveTime;
 
         /// <summary>
         /// The current websocket status
         /// </summary>
-        public SocketStatus SocketStatus => _connection.Status;
+        public SocketStatus SocketStatus => _connection?.Status ?? _manualSubscription!.SocketStatus;
 
         /// <summary>
         /// The current subscription status
@@ -143,6 +144,18 @@ namespace CryptoExchange.Net.Objects.Sockets
             _subscription.StatusChanged += (x) => SubscriptionStatusChanged?.Invoke(x);
         }
 
+        /// <summary>
+        /// ctor
+        /// </summary>
+        /// <param name="manualSubscription">The manual subscription for controlling events and data</param>
+        /// <param name="subscription">The subscription</param>
+        internal UpdateSubscription(ManualUpdateSubscription manualSubscription, Subscription subscription)
+        {
+            _manualSubscription = manualSubscription;
+            _subscription = subscription;
+            _subscription.StatusChanged += (x) => SubscriptionStatusChanged?.Invoke(x);
+        }
+
         private void UnsubscribeConnectionEvents()
         {
             lock (_eventLock)
@@ -150,22 +163,26 @@ namespace CryptoExchange.Net.Objects.Sockets
                 if (!_connectionEventsSubscribed)
                     return;
 
-                _connection.ConnectionClosed -= HandleConnectionClosedEvent;
-                _connection.ConnectionLost -= HandleConnectionLostEvent;
-                _connection.ConnectionRestored -= HandleConnectionRestoredEvent;
-                _connection.ResubscribingFailed -= HandleResubscribeFailedEvent;
-                _connection.ActivityPaused -= HandlePausedEvent;
-                _connection.ActivityUnpaused -= HandleUnpausedEvent;
+                if (_connection != null)
+                {
+                    _connection.ConnectionClosed -= HandleConnectionClosedEvent;
+                    _connection.ConnectionLost -= HandleConnectionLostEvent;
+                    _connection.ConnectionRestored -= HandleConnectionRestoredEvent;
+                    _connection.ResubscribingFailed -= HandleResubscribeFailedEvent;
+                    _connection.ActivityPaused -= HandlePausedEvent;
+                    _connection.ActivityUnpaused -= HandleUnpausedEvent;
+                }
+
                 _connectionEventsSubscribed = false;
             }
         }
 
-        private void HandleConnectionClosedEvent()
+        internal void HandleConnectionClosedEvent()
         {
             UnsubscribeConnectionEvents();
 
             // If we're not the subscription closing this connection don't bother emitting
-            if (!_subscription.IsClosingConnection)
+            if (_connection != null && !_subscription.IsClosingConnection)
                 return;
 
             List<Action> handlers;
@@ -176,7 +193,7 @@ namespace CryptoExchange.Net.Objects.Sockets
                 callback();
         }
 
-        private void HandleConnectionLostEvent()
+        internal void HandleConnectionLostEvent()
         {
             if (!_subscription.Active)
             {
@@ -192,7 +209,7 @@ namespace CryptoExchange.Net.Objects.Sockets
                 callback();
         }
 
-        private void HandleConnectionRestoredEvent(TimeSpan period)
+        internal void HandleConnectionRestoredEvent(TimeSpan period)
         {
             if (!_subscription.Active)
             {
@@ -208,7 +225,7 @@ namespace CryptoExchange.Net.Objects.Sockets
                 callback(period);
         }
 
-        private void HandleResubscribeFailedEvent(Error error)
+        internal void HandleResubscribeFailedEvent(Error error)
         {
             if (!_subscription.Active)
             {
@@ -224,7 +241,7 @@ namespace CryptoExchange.Net.Objects.Sockets
                 callback(error);
         }
 
-        private void HandlePausedEvent()
+        internal void HandlePausedEvent()
         {
             if (!_subscription.Active)
             {
@@ -240,7 +257,7 @@ namespace CryptoExchange.Net.Objects.Sockets
                 callback();
         }
 
-        private void HandleUnpausedEvent()
+        internal void HandleUnpausedEvent()
         {
             if (!_subscription.Active)
             {
@@ -262,7 +279,10 @@ namespace CryptoExchange.Net.Objects.Sockets
         /// <returns></returns>
         public Task CloseAsync()
         {
-            return _connection.CloseAsync(_subscription);
+            if (_connection != null)
+                return _connection.CloseAsync(_subscription);
+
+            return _manualSubscription!.CloseAsync();
         }
 
         /// <summary>
@@ -271,7 +291,10 @@ namespace CryptoExchange.Net.Objects.Sockets
         /// <returns></returns>
         public Task ReconnectAsync()
         {
-            return _connection.TriggerReconnectAsync();
+            if (_connection != null)
+                return _connection.TriggerReconnectAsync();
+
+            return _manualSubscription!.ReconnectAsync();
         }
 
         /// <summary>
@@ -280,7 +303,13 @@ namespace CryptoExchange.Net.Objects.Sockets
         /// <returns></returns>
         internal async Task UnsubscribeAsync()
         {
-            await _connection.UnsubscribeAsync(_subscription).ConfigureAwait(false);
+            if (_connection != null)
+            {
+                await _connection.UnsubscribeAsync(_subscription).ConfigureAwait(false);
+                return;
+            }
+
+            await _manualSubscription!.CloseAsync().ConfigureAwait(false);
         }
 
         /// <summary>
@@ -289,7 +318,10 @@ namespace CryptoExchange.Net.Objects.Sockets
         /// <returns></returns>
         internal async Task<CallResult> ResubscribeAsync()
         {
-            return await _connection.ResubscribeAsync(_subscription).ConfigureAwait(false);
+            if (_connection != null)
+                return await _connection.ResubscribeAsync(_subscription).ConfigureAwait(false);
+
+            return await _manualSubscription!.ResubscribeAsync().ConfigureAwait(false);
         }
     }
 }

CryptoExchange.Net/SharedApis/Enums/SharedAssetType.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Asset type
+    /// </summary>
+    public enum SharedAssetType
+    {
+        /// <summary>
+        /// Unknown or unspecified asset type
+        /// </summary>
+        Unspecified,
+        /// <summary>
+        /// Cryptocurrency asset type
+        /// </summary>
+        Crypto,
+        /// <summary>
+        /// Fiat currency asset type
+        /// </summary>
+        Fiat,
+        /// <summary>
+        /// Traditional finance asset type
+        /// </summary>
+        TradFi
+    }
+
+    /// <summary>
+    /// Asset sub type
+    /// </summary>
+    public enum SharedAssetSubType
+    {
+        // --- Crypto sub types ---
+        /// <summary>
+        /// Stable coin, can be for different fiat currencies
+        /// </summary>
+        StableCoin,
+
+        // --- TradFi sub types ---
+        /// <summary>
+        /// Equity, can be stocks, ETFs, or indices
+        /// </summary>
+        Equity,
+        /// <summary>
+        /// Commodity, can be oil, gas, metals, etc.
+        /// </summary>
+        Commodity
+    }
+}

CryptoExchange.Net/SharedApis/Interfaces/Rest/Futures/IFuturesSymbolRestClient.cs

@@ -9,6 +9,11 @@ namespace CryptoExchange.Net.SharedApis
     /// </summary>
     public interface IFuturesSymbolRestClient : ISharedClient
     {
+        /// <summary>
+        /// Get the futures symbol catalog. Only available if <see cref="GetFuturesSymbolsAsync(GetSymbolsRequest, CancellationToken)"/> has been called previously.
+        /// </summary>
+        SharedSymbolCatalog? FuturesSymbolCatalog { get; }
+
         /// <summary>
         /// Futures symbol request options.<br />
         /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />

CryptoExchange.Net/SharedApis/Interfaces/Rest/Spot/ISpotSymbolRestClient.cs

@@ -9,6 +9,11 @@ namespace CryptoExchange.Net.SharedApis
     /// </summary>
     public interface ISpotSymbolRestClient : ISharedClient
     {
+        /// <summary>
+        /// Get the spot symbol catalog. Only available if <see cref="GetSpotSymbolsAsync(GetSymbolsRequest, CancellationToken)"/> has been called previously.
+        /// </summary>
+        SharedSymbolCatalog? SpotSymbolCatalog { get; }
+
         /// <summary>
         /// Spot symbols request options.<br />
         /// Use <see cref="EndpointOptions.RequiredExchangeParameters"/> and <see cref="EndpointOptions.OptionalExchangeParameters"/> to check for required and optional parameters for the request. <br />

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/EndpointOptions.cs

@@ -70,7 +70,12 @@ namespace CryptoExchange.Net.SharedApis
             foreach (var param in RequiredExchangeParameters)
             {
                 if (param.Names!.All(x => ExchangeParameters.HasValue(exchangeParameters, Exchange, x, param.ValueType) != true))
-                    return ArgumentError.Invalid(string.Join("/", param.Names!), $"One of exchange parameters `{string.Join(", ", param.Names!)}` for exchange `{Exchange}` should be provided. Example: {param.ExampleValue}");
+                {
+                    if (param.Names.Length == 1)
+                        return ArgumentError.Invalid(string.Join("/", param.Names!), $"Exchange parameter `{param.Names[0]}` for exchange `{Exchange}` should be provided. Example: {param.ExampleValue}");
+                    else
+                        return ArgumentError.Invalid(string.Join("/", param.Names!), $"One of exchange parameters `{string.Join(", ", param.Names!)}` for exchange `{Exchange}` should be provided. Example: {param.ExampleValue}");
+                }
             }
 
             return null;
@@ -149,7 +154,12 @@ namespace CryptoExchange.Net.SharedApis
             foreach (var param in RequiredOptionalParameters)
             {
                 if (param.Names!.All(x => _requestProperties.Single(p => p.Name == x).GetValue(request, null) == null))
-                    return ArgumentError.Invalid(string.Join("/", param.Names!), $"One of optional parameters `{string.Join(", ", param.Names!)}` for exchange `{Exchange}` should be provided. Example: {param.ExampleValue}");
+                {
+                    if (param.Names.Length == 1)
+                        return ArgumentError.Invalid(string.Join("/", param.Names!), $"Optional parameter `{param.Names[0]}` for exchange `{Exchange}` should be provided. Example: {param.ExampleValue}");
+                    else
+                        return ArgumentError.Invalid(string.Join("/", param.Names!), $"One of optional parameters `{string.Join(", ", param.Names!)}` for exchange `{Exchange}` should be provided. Example: {param.ExampleValue}");
+                }
             }
 
             if (request is SharedSymbolRequest symbolsRequest)

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/GetFuturesSymbolsOptions.cs

@@ -1,4 +1,5 @@
-using System;
+using CryptoExchange.Net.Objects;
+using System;
 using System.Collections.Generic;
 using System.Text;
 
@@ -15,5 +16,43 @@ namespace CryptoExchange.Net.SharedApis
         public GetFuturesSymbolsOptions(string exchange, bool authenticated) : base(exchange, authenticated, nameof(IFuturesSymbolRestClient.GetFuturesSymbolsAsync))
         {
         }
+
+        /// <inheritdoc />
+        public override Error? ValidateRequest(GetSymbolsRequest request, IFuturesSymbolRestClient client)
+        {
+            if (request.BaseAssetType != null && request.BaseAssetSubType != null)
+            {
+                var error = ValidateAssetTypeCombination(request.BaseAssetType.Value, request.BaseAssetSubType.Value);
+                if (error != null)
+                    return error;
+            }
+
+            if (request.QuoteAssetType != null && request.QuoteAssetSubType != null)
+            {
+                var error = ValidateAssetTypeCombination(request.QuoteAssetType.Value, request.QuoteAssetSubType.Value);
+                if (error != null)
+                    return error;
+            }
+
+            return base.ValidateRequest(request, client);
+        }
+
+        private Error? ValidateAssetTypeCombination(SharedAssetType type, SharedAssetSubType subType)
+        {
+            if (type == SharedAssetType.Crypto
+                    && (subType == SharedAssetSubType.Commodity
+                    || (subType == SharedAssetSubType.Equity)))
+            {
+                return ArgumentError.Invalid(nameof(GetSymbolsRequest.BaseAssetSubType), $"Invalid combination of asset type filters: {type} and {subType}");
+            }
+
+            if (type == SharedAssetType.TradFi && subType == SharedAssetSubType.StableCoin)
+                return ArgumentError.Invalid(nameof(GetSymbolsRequest.BaseAssetSubType), $"Invalid combination of asset type filters: {type} and {subType}");
+
+            if (type == SharedAssetType.Fiat)
+                return ArgumentError.Invalid(nameof(GetSymbolsRequest.BaseAssetSubType), $"Invalid combination of asset type filters: {type} and {subType}");
+
+            return null;
+        }
     }
 }

CryptoExchange.Net/SharedApis/Models/Options/Endpoints/GetSpotSymbolsOptions.cs

@@ -1,4 +1,5 @@
-using System;
+using CryptoExchange.Net.Objects;
+using System;
 using System.Collections.Generic;
 using System.Text;
 
@@ -15,5 +16,44 @@ namespace CryptoExchange.Net.SharedApis
         public GetSpotSymbolsOptions(string exchange, bool authenticated) : base(exchange, authenticated, nameof(ISpotSymbolRestClient.GetSpotSymbolsAsync))
         {
         }
+
+
+        /// <inheritdoc />
+        public override Error? ValidateRequest(GetSymbolsRequest request, ISpotSymbolRestClient client)
+        {
+            if (request.BaseAssetType != null && request.BaseAssetSubType != null)
+            {
+                var error = ValidateAssetTypeCombination(request.BaseAssetType.Value, request.BaseAssetSubType.Value);
+                if (error != null)
+                    return error;
+            }
+
+            if (request.QuoteAssetType != null && request.QuoteAssetSubType != null)
+            {
+                var error = ValidateAssetTypeCombination(request.QuoteAssetType.Value, request.QuoteAssetSubType.Value);
+                if (error != null)
+                    return error;
+            }
+
+            return base.ValidateRequest(request, client);
+        }
+
+        private Error? ValidateAssetTypeCombination(SharedAssetType type, SharedAssetSubType subType)
+        {
+            if (type == SharedAssetType.Crypto
+                    && (subType == SharedAssetSubType.Commodity
+                    || (subType == SharedAssetSubType.Equity)))
+            {
+                return ArgumentError.Invalid(nameof(GetSymbolsRequest.BaseAssetSubType), $"Invalid combination of asset type filters: {type} and {subType}");
+            }
+
+            if (type == SharedAssetType.TradFi && subType == SharedAssetSubType.StableCoin)
+                return ArgumentError.Invalid(nameof(GetSymbolsRequest.BaseAssetSubType), $"Invalid combination of asset type filters: {type} and {subType}");
+
+            if (type == SharedAssetType.Fiat)
+                return ArgumentError.Invalid(nameof(GetSymbolsRequest.BaseAssetSubType), $"Invalid combination of asset type filters: {type} and {subType}");
+
+            return null;
+        }
     }
 }

CryptoExchange.Net/SharedApis/Models/Rest/GetSymbolsRequest.cs

@@ -5,13 +5,44 @@
     /// </summary>
     public record GetSymbolsRequest : SharedRequest
     {
+        /// <summary>
+        /// Base asset type filter
+        /// </summary>
+        public SharedAssetType? BaseAssetType { get; }
+        /// <summary>
+        /// Base asset subtype filter
+        /// </summary>
+        public SharedAssetSubType? BaseAssetSubType { get; }
+        /// <summary>
+        /// Quote asset type filter
+        /// </summary>
+        public SharedAssetType? QuoteAssetType { get; }
+        /// <summary>
+        /// Quote asset subtype filter
+        /// </summary>
+        public SharedAssetSubType? QuoteAssetSubType { get; }
+
         /// <summary>
         /// ctor
         /// </summary>
         /// <param name="tradingMode">Trading mode filter</param>
+        /// <param name="baseAssetType">Filter by base asset type</param>
+        /// <param name="baseAssetSubType">Filter by base asset subtype</param>
+        /// <param name="quoteAssetType">Filter by quote asset type</param>
+        /// <param name="quoteAssetSubType">Filter by quote asset subtype</param>
         /// <param name="exchangeParameters">Exchange specific parameters</param>
-        public GetSymbolsRequest(TradingMode? tradingMode = null, ExchangeParameters? exchangeParameters = null) : base(tradingMode, exchangeParameters)
+        public GetSymbolsRequest(
+            TradingMode? tradingMode = null,
+            SharedAssetType? baseAssetType = null, 
+            SharedAssetSubType? baseAssetSubType = null,
+            SharedAssetType? quoteAssetType = null,
+            SharedAssetSubType? quoteAssetSubType = null,
+            ExchangeParameters? exchangeParameters = null) : base(tradingMode, exchangeParameters)
         {
+            BaseAssetType = baseAssetType;
+            BaseAssetSubType = baseAssetSubType;
+            QuoteAssetType = quoteAssetType;
+            QuoteAssetSubType = quoteAssetSubType;
         }
     }
 }

CryptoExchange.Net/SharedApis/Models/SharedSymbolCatalog.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+
+namespace CryptoExchange.Net.SharedApis
+{
+    /// <summary>
+    /// Symbol and asset catalog for a shared client
+    /// </summary>
+    public class SharedSymbolCatalog
+    {
+        /// <summary>
+        /// Exchange name
+        /// </summary>
+        public string Exchange { get; set; } = string.Empty;
+        /// <summary>
+        /// Assets supported
+        /// </summary>
+        public IReadOnlyDictionary<string, SharedAssetInfo> Assets { get; set; } = new Dictionary<string, SharedAssetInfo>();
+        /// <summary>
+        /// Symbols supported
+        /// </summary>
+        public IReadOnlyDictionary<string, SharedSpotSymbol> Symbols { get; set; } = new Dictionary<string, SharedSpotSymbol>();
+    }
+
+    /// <summary>
+    /// Asset info
+    /// </summary>
+    [DebuggerDisplay("{DebugView,nq}")]
+    public class SharedAssetInfo
+    {
+        private string DebugView => $"{Name} - {Type}{(SubType == null ? "": $" {SubType}")}";
+
+        /// <summary>
+        /// Asset name
+        /// </summary>
+        public string Name { get; set; }
+        /// <summary>
+        /// Asset type
+        /// </summary>
+        public SharedAssetType Type { get; set; }
+        /// <summary>
+        /// Asset sub type
+        /// </summary>
+        public SharedAssetSubType? SubType { get; set; }
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public SharedAssetInfo(string name, SharedAssetType type, SharedAssetSubType? subType)
+        {
+            Name = name;
+            Type = type;
+            SubType = subType;
+        }
+    }
+}

CryptoExchange.Net/SharedApis/ResponseModels/SharedAsset.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Asset info
     /// </summary>
+    [DebuggerDisplay("{Name,nq} - {Networks.Length} network(s)")]
     public record SharedAsset
     {
         /// <summary>
@@ -32,6 +34,7 @@ namespace CryptoExchange.Net.SharedApis
     /// <summary>
     /// Asset network info
     /// </summary>
+    [DebuggerDisplay("{Name,nq}")]
     public record SharedAssetNetwork
     {
         /// <summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedBalance.cs

@@ -1,8 +1,11 @@
-namespace CryptoExchange.Net.SharedApis
+using System.Diagnostics;
+
+namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Balance info
     /// </summary>
+    [DebuggerDisplay("{Available} {Asset, nq}")]
     public record SharedBalance
     {
         /// <summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedBookTicker.cs

@@ -1,8 +1,11 @@
-namespace CryptoExchange.Net.SharedApis
+using System.Diagnostics;
+
+namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Book ticker
     /// </summary>
+    [DebuggerDisplay("{Symbol,nq} - {BestBidPrice} / {BestAskPrice}")]
     public record SharedBookTicker : SharedSymbolModel
     {
         /// <summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedDeposit.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Deposit info
     /// </summary>
+    [DebuggerDisplay("[{Timestamp}] {Quantity} {Asset,nq}")]
     public record SharedDeposit
     {
         /// <summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedDepositAddress.cs

@@ -1,8 +1,11 @@
-namespace CryptoExchange.Net.SharedApis
+using System.Diagnostics;
+
+namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Deposit address info
     /// </summary>
+    [DebuggerDisplay("{Asset,nq} - {Address,nq}")]
     public record SharedDepositAddress
     {
         /// <summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedFee.cs

@@ -1,8 +1,11 @@
-namespace CryptoExchange.Net.SharedApis
+using System.Diagnostics;
+
+namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Trading fee info
     /// </summary>
+    [DebuggerDisplay("{MakerFee} / {TakerFee}")]
     public record SharedFee
     {
         /// <summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedFundingRate.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Funding rate
     /// </summary>
+    [DebuggerDisplay("[{Timestamp}] {FundingRate}")]
     public record SharedFundingRate
     {
         /// <summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedFuturesKline.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Mark/index price kline
     /// </summary>
+    [DebuggerDisplay("[{OpenTime}] O: {OpenPrice} H: {HighPrice} L: {LowPrice} C: {ClosePrice}")]
     public record SharedFuturesKline : SharedSymbolModel
     {
         /// <summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedFuturesOrder.cs

@@ -1,12 +1,19 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Futures order info
     /// </summary>
+    [DebuggerDisplay("{DebugView,nq}")]
     public record SharedFuturesOrder : SharedSymbolModel
     {
+        private string DebugView => 
+            $"[{CreateTime}] {OrderId} {(PositionSide != null ? $"{PositionSide} " : "")}{Symbol}  - " +
+            $"{OrderType} {Side} {OrderQuantity}{(OrderPrice != null ? " @ " + OrderPrice : "")}, " +
+            $"{Status}{(QuantityFilled != null && Status != SharedOrderStatus.Canceled ? $" {QuantityFilled}" : "")}{(AveragePrice != null ? " @ " + AveragePrice : "")}";
+
         /// <summary>
         /// Id of the order
         /// </summary>
@@ -47,10 +54,18 @@ namespace CryptoExchange.Net.SharedApis
         /// Order price
         /// </summary>
         public decimal? OrderPrice { get; set; }
+        private decimal? _averagePrice;
         /// <summary>
-        /// Average price
+        /// Average fill price
         /// </summary>
-        public decimal? AveragePrice { get; set; }
+        public decimal? AveragePrice
+        {
+            get => _averagePrice > 0 ? _averagePrice
+                : (QuantityFilled?.QuantityInBaseAsset > 0 && QuantityFilled?.QuantityInQuoteAsset > 0
+                    ? QuantityFilled.QuantityInQuoteAsset / QuantityFilled.QuantityInBaseAsset
+                    : null);
+            set => _averagePrice = value;
+        }
         /// <summary>
         /// Client order id
         /// </summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedFuturesSymbol.cs

@@ -1,12 +1,17 @@
 using System;
+using System.Diagnostics;
+using System.Drawing;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Futures symbol info
     /// </summary>
+    [DebuggerDisplay("{DebugView,nq}")]
     public record SharedFuturesSymbol : SharedSpotSymbol
     {
+        private string DebugView => $"{TradingMode} {(DisplayName ?? Name)} - {BaseAssetType}{(BaseAssetSubType == null ? "" : " " + BaseAssetSubType)}{(DeliveryTime != null ? $" Delivery: {DeliveryTime:yyyy-MM-dd}": "")}";
+
         /// <summary>
         /// The size of a single contract
         /// </summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedFuturesTicker.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Futures ticker info
     /// </summary>
+    [DebuggerDisplay("{Symbol,nq} High: {HighPrice}, Low: {LowPrice}, Last: {LastPrice}, Change: {ChangePercentage}%")]
     public record SharedFuturesTicker: SharedSymbolModel
     {
         /// <summary>
@@ -22,7 +24,24 @@ namespace CryptoExchange.Net.SharedApis
         /// <summary>
         /// The volume in the last 24h
         /// </summary>
-        public decimal Volume { get; set; }
+        public SharedOrderQuantity Volumes { get; set; }
+
+        private decimal? _volume;
+        /// <summary>
+        /// The volume in the last 24h
+        /// </summary>
+        [Obsolete("Use `Volumes` instead")]
+        public decimal Volume
+        {
+            get
+            {
+                if (_volume.HasValue)
+                    return _volume.Value;
+
+                return Volumes.QuantityInBaseAsset ?? Volumes.QuantityInContracts ?? 0;
+            }
+            set => _volume = value;
+        }
         /// <summary>
         /// Change percentage in the last 24h
         /// </summary>
@@ -47,13 +66,20 @@ namespace CryptoExchange.Net.SharedApis
         /// <summary>
         /// ctor
         /// </summary>
-        public SharedFuturesTicker(SharedSymbol? sharedSymbol, string symbol, decimal? lastPrice, decimal? highPrice, decimal? lowPrice, decimal volume, decimal? changePercentage)
+        public SharedFuturesTicker(
+            SharedSymbol? sharedSymbol, 
+            string symbol, 
+            decimal? lastPrice, 
+            decimal? highPrice,
+            decimal? lowPrice, 
+            SharedOrderQuantity volumes, 
+            decimal? changePercentage)
             :base(sharedSymbol, symbol)
         {
             LastPrice = lastPrice;
             HighPrice = highPrice;
             LowPrice = lowPrice;
-            Volume = volume;
+            Volumes = volumes;
             ChangePercentage = changePercentage;
         }
     }

CryptoExchange.Net/SharedApis/ResponseModels/SharedKline.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Kline info
     /// </summary>
+    [DebuggerDisplay("[{OpenTime}] O: {OpenPrice} H: {HighPrice} L: {LowPrice} C: {ClosePrice} V: {Volumes}")]
     public record SharedKline : SharedSymbolModel
     {
         /// <summary>
@@ -27,15 +29,40 @@ namespace CryptoExchange.Net.SharedApis
         /// Open price
         /// </summary>
         public decimal OpenPrice { get; set; }
+
+        private decimal? _volume;
         /// <summary>
         /// Volume in the base asset
         /// </summary>
-        public decimal Volume { get; set; }
+        [Obsolete("Use `Volumes` instead")]
+        public decimal Volume
+        {
+            get
+            {
+                if (_volume.HasValue)
+                    return _volume.Value;
+
+                return Volumes.QuantityInBaseAsset ?? Volumes.QuantityInContracts ?? 0;
+            }
+            set => _volume = value;
+        }
+        /// <summary>
+        /// The volume in the last 24h
+        /// </summary>
+        public SharedOrderQuantity Volumes { get; set; }
 
         /// <summary>
         /// ctor
         /// </summary>
-        public SharedKline(SharedSymbol? sharedSymbol, string symbol, DateTime openTime, decimal closePrice, decimal highPrice, decimal lowPrice, decimal openPrice, decimal volume)
+        public SharedKline(
+            SharedSymbol? sharedSymbol,
+            string symbol,
+            DateTime openTime, 
+            decimal closePrice, 
+            decimal highPrice,
+            decimal lowPrice,
+            decimal openPrice,
+            SharedOrderQuantity volumes)
             : base(sharedSymbol, symbol)
         {
             OpenTime = openTime;
@@ -43,7 +70,7 @@ namespace CryptoExchange.Net.SharedApis
             HighPrice = highPrice;
             LowPrice = lowPrice;
             OpenPrice = openPrice;
-            Volume = volume;
+            Volumes = volumes;
         }
     }
 }

CryptoExchange.Net/SharedApis/ResponseModels/SharedPosition.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Position info
     /// </summary>
+    [DebuggerDisplay("{Symbol,nq} {PositionSide}: {PositionSize} {AverageOpenPrice}")]
     public record SharedPosition : SharedSymbolModel
     {
         /// <summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedPositionHistory.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Position history
     /// </summary>
+    [DebuggerDisplay("[{Timestamp}] {Symbol,nq} {PositionSide}: {RealizedPnl}")]
     public record SharedPositionHistory : SharedSymbolModel
     {
         /// <summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedSpotOrder.cs

@@ -1,12 +1,19 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Spot order info
     /// </summary>
+    [DebuggerDisplay("{DebugView,nq}")]
     public record SharedSpotOrder : SharedSymbolModel
     {
+        private string DebugView =>
+            $"[{CreateTime}] {OrderId} {Symbol}  - " +
+            $"{OrderType} {Side} {OrderQuantity}{(OrderPrice != null ? " @ " + OrderPrice : "")}, " +
+            $"{Status}{(QuantityFilled != null && Status != SharedOrderStatus.Canceled ? $" {QuantityFilled}" : "")}{(AveragePrice != null ? " @ " + AveragePrice : "")}";
+
         /// <summary>
         /// The id of the order
         /// </summary>
@@ -39,10 +46,18 @@ namespace CryptoExchange.Net.SharedApis
         /// Order price
         /// </summary>
         public decimal? OrderPrice { get; set; }
+        private decimal? _averagePrice;
         /// <summary>
         /// Average fill price
         /// </summary>
-        public decimal? AveragePrice { get; set; }
+        public decimal? AveragePrice
+        {
+            get => _averagePrice > 0 ? _averagePrice 
+                : (QuantityFilled?.QuantityInBaseAsset > 0 && QuantityFilled?.QuantityInQuoteAsset > 0 
+                    ? QuantityFilled.QuantityInQuoteAsset / QuantityFilled.QuantityInBaseAsset 
+                    : null);
+            set => _averagePrice = value;
+        }
         /// <summary>
         /// Client order id
         /// </summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedSpotSymbol.cs

@@ -1,10 +1,17 @@
-namespace CryptoExchange.Net.SharedApis
+using System;
+using System.Data;
+using System.Diagnostics;
+
+namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Symbol info
     /// </summary>
+    [DebuggerDisplay("{DebugView,nq}")]
     public record SharedSpotSymbol
     {
+        private string DebugView => $"{TradingMode} {(DisplayName ?? Name)} - {BaseAssetType} {BaseAssetSubType}";
+
         /// <summary>
         /// The trading mode of the symbol
         /// </summary>
@@ -22,6 +29,10 @@
         /// </summary>
         public string Name { get; set; }
         /// <summary>
+        /// The display name of the symbol
+        /// </summary>
+        public string? DisplayName { get; set; }
+        /// <summary>
         /// Minimal quantity of an order in the base asset
         /// </summary>
         public decimal? MinTradeQuantity { get; set; }
@@ -57,6 +68,22 @@
         /// Whether the symbol is currently available for trading
         /// </summary>
         public bool Trading { get; set; }
+        /// <summary>
+        /// Base asset type
+        /// </summary>
+        public SharedAssetType BaseAssetType { get; set; }
+        /// <summary>
+        /// Base asset sub type
+        /// </summary>
+        public SharedAssetSubType? BaseAssetSubType { get; set; }
+        /// <summary>
+        /// Quote asset type
+        /// </summary>
+        public SharedAssetType QuoteAssetType { get; set; }
+        /// <summary>
+        /// Quote asset sub type
+        /// </summary>
+        public SharedAssetSubType? QuoteAssetSubType { get; set; }
 
         /// <summary>
         /// ctor

CryptoExchange.Net/SharedApis/ResponseModels/SharedSpotTicker.cs

@@ -1,8 +1,12 @@
-namespace CryptoExchange.Net.SharedApis
+using System;
+using System.Diagnostics;
+
+namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Ticker info
     /// </summary>
+    [DebuggerDisplay("{Symbol,nq} High: {HighPrice}, Low: {LowPrice}, Last: {LastPrice}, Change: {ChangePercentage}%")]
     public record SharedSpotTicker: SharedSymbolModel
     {
         /// <summary>
@@ -18,13 +22,31 @@
         /// </summary>
         public decimal? LowPrice { get; set; }
         /// <summary>
+        /// The volume in the last 24h
+        /// </summary>
+        public SharedOrderQuantity Volumes { get; set; }
+
+        private decimal? _volume;
+        /// <summary>
         /// Trade volume in base asset in the last 24h
         /// </summary>
-        public decimal Volume { get; set; }
+        [Obsolete("Use `Volumes` instead")]
+        public decimal Volume
+        {
+            get
+            {
+                if (_volume.HasValue)
+                    return _volume.Value;
+
+                return Volumes.QuantityInBaseAsset ?? Volumes.QuantityInContracts ?? 0;
+            }
+            set => _volume = value;
+        }
         /// <summary>
         /// Trade volume in quote asset in the last 24h
         /// </summary>
-        public decimal? QuoteVolume { get; set; }
+        [Obsolete("Use `Volumes` instead")]
+        public decimal? QuoteVolume => Volumes?.QuantityInQuoteAsset;
         /// <summary>
         /// Change percentage in the last 24h
         /// </summary>
@@ -33,13 +55,20 @@
         /// <summary>
         /// ctor
         /// </summary>
-        public SharedSpotTicker(SharedSymbol? sharedSymbol, string symbol, decimal? lastPrice, decimal? highPrice, decimal? lowPrice, decimal volume, decimal? changePercentage)
+        public SharedSpotTicker(
+            SharedSymbol? sharedSymbol,
+            string symbol,
+            decimal? lastPrice,
+            decimal? highPrice,
+            decimal? lowPrice,
+            SharedOrderQuantity volumes,
+            decimal? changePercentage)
             : base(sharedSymbol, symbol)
         {
             LastPrice = lastPrice;
             HighPrice = highPrice;
             LowPrice = lowPrice;
-            Volume = volume;
+            Volumes = volumes;
             ChangePercentage = changePercentage;
         }
     }

CryptoExchange.Net/SharedApis/ResponseModels/SharedTrade.cs

@@ -1,16 +1,23 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// Public trade info
     /// </summary>
+    [DebuggerDisplay("[{Timestamp}] {Symbol,nq} {Side.ToString(),nq} {Quantity} @ {Price}")]
     public record SharedTrade : SharedSymbolModel
     {
         /// <summary>
         /// Quantity of the trade
         /// </summary>
-        public decimal Quantity { get; set; }
+        [Obsolete("Use `Quantities` instead")]
+        public decimal Quantity => Quantities.QuantityInBaseAsset ?? Quantities.QuantityInContracts ?? 0;
+        /// <summary>
+        /// The quantities of the trade
+        /// </summary>
+        public SharedOrderQuantity Quantities { get; set; }
         /// <summary>
         /// Price of the trade
         /// </summary>
@@ -27,9 +34,9 @@ namespace CryptoExchange.Net.SharedApis
         /// <summary>
         /// ctor
         /// </summary>
-        public SharedTrade(SharedSymbol? sharedSymbol, string symbol, decimal quantity, decimal price, DateTime timestamp) : base(sharedSymbol, symbol)
+        public SharedTrade(SharedSymbol? sharedSymbol, string symbol, SharedOrderQuantity quantities, decimal price, DateTime timestamp) : base(sharedSymbol, symbol)
         {
-            Quantity = quantity;
+            Quantities = quantities;
             Price = price;
             Timestamp = timestamp;
         }

CryptoExchange.Net/SharedApis/ResponseModels/SharedUserTrade.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// A user trade
     /// </summary>
+    [DebuggerDisplay("[{Timestamp}] {Id,nq} {Symbol,nq} {Side.ToString(),nq} {Quantity} @ {Price}")]
     public record SharedUserTrade : SharedSymbolModel
     {
         /// <summary>

CryptoExchange.Net/SharedApis/ResponseModels/SharedWithdrawal.cs

@@ -1,10 +1,12 @@
 using System;
+using System.Diagnostics;
 
 namespace CryptoExchange.Net.SharedApis
 {
     /// <summary>
     /// A withdrawal record
     /// </summary>
+    [DebuggerDisplay("[{Timestamp}] {Quantity} {Asset,nq}")]
     public record SharedWithdrawal
     {
         /// <summary>

CryptoExchange.Net/SharedApis/SharedQuantity.cs

@@ -1,4 +1,5 @@
 using CryptoExchange.Net.Converters.SystemTextJson;
+using System.Text;
 using System.Text.Json.Serialization;
 
 namespace CryptoExchange.Net.SharedApis
@@ -35,6 +36,33 @@ namespace CryptoExchange.Net.SharedApis
             QuantityInQuoteAsset = quoteAssetQuantity;
             QuantityInContracts = contractQuantity;
         }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            var sb = new StringBuilder("[");
+            if (QuantityInBaseAsset != null)            
+                sb.Append($"{QuantityInBaseAsset} base");
+            
+            if (QuantityInQuoteAsset != null)
+            {
+                if (sb.Length > 1)
+                    sb.Append(", ");
+
+                sb.Append($"{QuantityInQuoteAsset} quote");
+            }
+
+            if (QuantityInContracts != null)
+            {
+                if (sb.Length > 1)
+                    sb.Append(", ");
+
+                sb.Append($"{QuantityInContracts} contracts");
+            }
+
+            sb.Append("]");
+            return sb.ToString();
+        }
     }
 
     /// <summary>
@@ -53,6 +81,9 @@ namespace CryptoExchange.Net.SharedApis
         /// </summary>
         public SharedQuantity() : base(null, null, null) { }
 
+        /// <inheritdoc />
+        public override string ToString() => base.ToString();
+
         /// <summary>
         /// Specify quantity in base asset
         /// </summary>
@@ -111,6 +142,11 @@ namespace CryptoExchange.Net.SharedApis
     [JsonConverter(typeof(SharedOrderQuantityConverter))]
     public record SharedOrderQuantity : SharedQuantityReference
     {
+        /// <summary>
+        /// The average price based on the base and quote asset quantities
+        /// </summary>
+        public decimal? AveragePrice => QuantityInBaseAsset == 0 ? null : QuantityInQuoteAsset / QuantityInBaseAsset;
+
         /// <summary>
         /// ctor
         /// </summary>
@@ -123,5 +159,24 @@ namespace CryptoExchange.Net.SharedApis
             : base(baseAssetQuantity, quoteAssetQuantity, contractQuantity)
         {
         }
+
+        /// <summary>
+        /// Get the quantity in quote asset. Will use the set `QuantityInQuoteAsset` property if it has a value, or `QuantityInBaseAsset` * `price` if not. Null otherwise.
+        /// </summary>
+        /// <param name="price">The price to use for the QuantityInBaseAsset to quote asset quantity calculation</param>
+        /// <returns>Quantity in quote asset if it's available or can be calculated, null otherwise</returns>
+        public decimal? GetQuantityInQuoteAsset(decimal? price)
+        {
+            if (QuantityInQuoteAsset != null)
+                return QuantityInQuoteAsset;
+
+            if (QuantityInBaseAsset != null && price != null)
+                return QuantityInBaseAsset * price;
+
+            return null;
+        }
+
+        /// <inheritdoc />
+        public override string ToString() => base.ToString();
     }
 }

CryptoExchange.Net/SharedApis/SharedUtils.cs

@@ -1,5 +1,6 @@
 using CryptoExchange.Net.Objects;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace CryptoExchange.Net.SharedApis
 {
@@ -176,5 +177,24 @@ namespace CryptoExchange.Net.SharedApis
 
             return result.ToArray();
         }
+
+        /// <summary>
+        /// Apply symbols request filter for asset type and trading mode
+        /// </summary>
+        public static T[] ApplySymbolFilter<T>(T[] symbols, GetSymbolsRequest request) where T : SharedSpotSymbol
+        {
+            IEnumerable<T> resultData = symbols;
+            if (request.TradingMode != null)
+                resultData = resultData.Where(x => x.TradingMode == request.TradingMode);
+            if (request.BaseAssetType != null)
+                resultData = resultData.Where(x => x.BaseAssetType == request.BaseAssetType);
+            if (request.QuoteAssetType != null)
+                resultData = resultData.Where(x => x.QuoteAssetType == request.QuoteAssetType);
+            if (request.BaseAssetSubType != null)
+                resultData = resultData.Where(x => x.BaseAssetSubType == request.BaseAssetSubType);
+            if (request.QuoteAssetSubType != null)
+                resultData = resultData.Where(x => x.QuoteAssetSubType == request.QuoteAssetSubType);
+            return resultData.ToArray();
+        }
     }
 }

CryptoExchange.Net/Sockets/Default/SocketConnection.cs

@@ -607,7 +607,7 @@ namespace CryptoExchange.Net.Sockets.Default
                         SocketId,
                         typeIdentifier,
                         topicFilter!,
-                        string.Join(",", _listeners.Select(x => string.Join(",", x.MessageRouter.Routes.Where(x => x.TypeIdentifier == typeIdentifier).Select(x => x.TopicFilter != null ? string.Join(",", x.TopicFilter) : "[null]")))));
+                        string.Join(",", _listeners.SelectMany(x => x.MessageRouter.Routes.Where(x => x.TypeIdentifier == typeIdentifier).Select(x => x.TopicFilter ?? "[null]"))));
                 }
             }
         }

CryptoExchange.Net/Testing/Comparers/SystemTextJsonComparer.cs

@@ -8,6 +8,7 @@ using System.Text.Json;
 using System.Text.Json.Serialization;
 using CryptoExchange.Net.Converters;
 using CryptoExchange.Net.Converters.SystemTextJson;
+using CryptoExchange.Net.Testing.Exceptions;
 
 #pragma warning disable IL2026
 #pragma warning disable IL2070
@@ -18,7 +19,7 @@ namespace CryptoExchange.Net.Testing.Comparers
 {
     internal class SystemTextJsonComparer
     {
-        internal static void CompareData(
+        internal static List<Exception> CompareData(
             string method,
             object? resultData,
             string json,
@@ -26,6 +27,7 @@ namespace CryptoExchange.Net.Testing.Comparers
             List<string>? ignoreProperties = null,
             bool userSingleArrayItem = false)
         {
+            var outputExceptions = new List<Exception>();
             var jsonObject = JsonDocument.Parse(json).RootElement;
             if (nestedJsonProperty != null)
             {
@@ -46,10 +48,10 @@ namespace CryptoExchange.Net.Testing.Comparers
             if (resultData == null)
             {
                 if (jsonObject.ValueKind == JsonValueKind.Null)
-                    return;
+                    return outputExceptions;
 
                 if (jsonObject.ValueKind == JsonValueKind.Object && jsonObject.GetPropertyCount() == 0)
-                    return;
+                    return outputExceptions;
 
                 throw new Exception("ResultData null");
             }
@@ -61,13 +63,16 @@ namespace CryptoExchange.Net.Testing.Comparers
                 foreach (var dictProp in jObj.EnumerateObject())
                 {
                     if (!dict.Contains(dictProp.Name))
-                        throw new Exception($"{method}: Dictionary has no value for {dictProp.Name} while input json `{dictProp.Name}` has value {dictProp.Value}");
+                    {
+                        outputExceptions.Add(new Exception($"{method}: Dictionary has no value for {dictProp.Name} while input json `{dictProp.Name}` has value {dictProp.Value}"));
+                        continue;
+                    }
 
                     if (dictProp.Value.ValueKind == JsonValueKind.Object)
                     {
                         // TODO Some additional checking for objects
                         foreach (var prop in dictProp.Value.EnumerateObject())
-                            CheckObject(method, prop, dict[dictProp.Name]!, ignoreProperties!);
+                            CheckObject(method, prop, dict[dictProp.Name]!, ignoreProperties!, outputExceptions);
                     }
                     else
                     {
@@ -77,7 +82,8 @@ namespace CryptoExchange.Net.Testing.Comparers
                                 continue;
 
                             // Property value not correct
-                            throw new Exception($"{method}: Dictionary entry `{dictProp.Name}` has no value while input json has value {dictProp.Value}");
+                            outputExceptions.Add(new Exception($"{method}: Dictionary entry `{dictProp.Name}` has no value while input json has value {dictProp.Value}"));
+                            continue;
                         }
                     }
                 }
@@ -99,7 +105,7 @@ namespace CryptoExchange.Net.Testing.Comparers
                             {
                                 if (ignoreProperties?.Contains(subProp.Name) == true)
                                     continue;
-                                CheckObject(method, subProp, enumerator.Current, ignoreProperties!);
+                                CheckObject(method, subProp, enumerator.Current, ignoreProperties!, outputExceptions);
                             }
                         }
                         else if (jObj.ValueKind == JsonValueKind.Array)
@@ -121,7 +127,7 @@ namespace CryptoExchange.Net.Testing.Comparers
                             {
                                 var arrayProp = resultProps.Where(p => p.Item2 != null).FirstOrDefault(p => p.Item2!.Index == i).p;
                                 if (arrayProp != null)
-                                    CheckPropertyValue(method, item.Value, arrayProp.GetValue(resultObj), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!);
+                                    CheckPropertyValue(method, item.Value, arrayProp.GetValue(resultObj), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!, outputExceptions);
                                 i++;
                             }
                         }
@@ -129,7 +135,10 @@ namespace CryptoExchange.Net.Testing.Comparers
                         {
                             var value = enumerator.Current;
                             if (value == default && jObj.ValueKind != JsonValueKind.Null)
-                                throw new Exception($"{method}: Array has no value while input json array has value {jObj}");
+                            {
+                                outputExceptions.Add(new Exception($"{method}: Array has no value while input json array has value {jObj}"));
+                                continue;
+                            }
                         }
                     }
                 }
@@ -141,7 +150,7 @@ namespace CryptoExchange.Net.Testing.Comparers
                     {
                         var arrayProp = resultProps.Where(p => p.Item2 != null).FirstOrDefault(p => p.Item2!.Index == i).p;
                         if (arrayProp != null)
-                            CheckPropertyValue(method, item, arrayProp.GetValue(resultData), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!);
+                            CheckPropertyValue(method, item, arrayProp.GetValue(resultData), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!, outputExceptions);
                         i++;
                     }
                 }
@@ -155,7 +164,7 @@ namespace CryptoExchange.Net.Testing.Comparers
                         if (ignoreProperties?.Contains(item.Name) == true)
                             continue;
 
-                        CheckObject(method, item, resultData, ignoreProperties);
+                        CheckObject(method, item, resultData, ignoreProperties, outputExceptions);
                     //}
                 }
             }
@@ -165,9 +174,10 @@ namespace CryptoExchange.Net.Testing.Comparers
             }
 
             Debug.WriteLine($"Successfully validated {method}");
+            return outputExceptions.Distinct().ToList();
         }
 
-        private static void CheckObject(string method, JsonProperty prop, object obj, List<string>? ignoreProperties)
+        private static void CheckObject(string method, JsonProperty prop, object obj, List<string>? ignoreProperties, List<Exception> outputExceptions)
         {
             var publicProperties = obj.GetType().GetProperties(
                 System.Reflection.BindingFlags.Public 
@@ -190,8 +200,11 @@ namespace CryptoExchange.Net.Testing.Comparers
             property ??= resultProperties.SingleOrDefault(p => p.p.Name == prop.Name).p;
 
             if (property is null)
+            {
                 // Property not found
-                throw new Exception($"{method}: Missing property `{prop.Name}` on `{obj.GetType().Name}`");
+                outputExceptions.Add(new MissingPropertyException(method, obj.GetType().Name, prop.Name, prop.Value.ValueKind == JsonValueKind.Null ? "[null]" : prop.Value.ToString()));
+                return;
+            }
 
             var getMethod = property.GetGetMethod();
             if (getMethod is null)
@@ -199,10 +212,18 @@ namespace CryptoExchange.Net.Testing.Comparers
                 return;
 
             var propertyValue = property.GetValue(obj);
-            CheckPropertyValue(method, prop.Value, propertyValue, property.PropertyType, property.Name, prop.Name, ignoreProperties);
+            CheckPropertyValue(method, prop.Value, propertyValue, property.PropertyType, property.Name, prop.Name, ignoreProperties, outputExceptions);
         }
 
-        private static void CheckPropertyValue(string method, JsonElement propValue, object? propertyValue, Type propertyType, string? propertyName = null, string? propName = null, List<string>? ignoreProperties = null)
+        private static void CheckPropertyValue(
+            string method,
+            JsonElement propValue, 
+            object? propertyValue, 
+            Type propertyType, 
+            string? propertyName, 
+            string? propName, 
+            List<string>? ignoreProperties, 
+            List<Exception> outputExceptions)
         {
             if (propertyValue == default && propValue.ValueKind != JsonValueKind.Null && !string.IsNullOrEmpty(propValue.ToString()))
             {
@@ -211,7 +232,10 @@ namespace CryptoExchange.Net.Testing.Comparers
 
                 // Property value not correct
                 if (propValue.ToString() != "0")
-                    throw new Exception($"{method}: Property `{propertyName}` has no value while input json `{propName}` has value {propValue}");
+                {
+                    outputExceptions.Add(new Exception($"{method}: Property `{propertyName}` has no value while input json `{propName}` has value {propValue}"));
+                    return;
+                }
             }
 
             if ((propertyValue == default && (propValue.ValueKind == JsonValueKind.Null || string.IsNullOrEmpty(propValue.ToString()))) || propValue.ToString() == "0")
@@ -223,17 +247,23 @@ namespace CryptoExchange.Net.Testing.Comparers
                 foreach (var dictProp in propValue.EnumerateObject())
                 {
                     if (!dict.Contains(dictProp.Name))
-                        throw new Exception($"{method}: Property `{propertyName}` has no value while input json `{propName}` has value {propValue}");
+                    {
+                        outputExceptions.Add(new Exception($"{method}: Property `{propertyName}` has no value while input json `{propName}` has value {propValue}"));
+                        continue;
+                    }
 
                     if (dictProp.Value.ValueKind == JsonValueKind.Object)
                     {
-                        CheckPropertyValue(method, dictProp.Value, dict[dictProp.Name]!, dict[dictProp.Name]!.GetType(), null, null, ignoreProperties);
+                        CheckPropertyValue(method, dictProp.Value, dict[dictProp.Name]!, dict[dictProp.Name]!.GetType(), null, null, ignoreProperties, outputExceptions);
                     }
                     else
                     {
                         if (dict[dictProp.Name] == default && dictProp.Value.ValueKind != JsonValueKind.Null)
+                        {
                             // Property value not correct
-                            throw new Exception($"{method}: Dictionary entry `{dictProp.Name}` has no value while input json has value {propValue} for");
+                            outputExceptions.Add(new Exception($"{method}: Dictionary entry `{dictProp.Name}` has no value while input json has value {propValue} for"));
+                            continue;
+                        }
                     }
                 }
             }
@@ -263,7 +293,7 @@ namespace CryptoExchange.Net.Testing.Comparers
                             if (ignoreProperties?.Contains(subProp.Name) == true)
                                 continue;
 
-                            CheckObject(method, subProp, enumerator.Current, ignoreProperties);
+                            CheckObject(method, subProp, enumerator.Current, ignoreProperties, outputExceptions);
                         }
                     }
                     else if (jToken.ValueKind == JsonValueKind.Array)
@@ -281,7 +311,7 @@ namespace CryptoExchange.Net.Testing.Comparers
                         {
                             var arrayProp = resultProps.Where(p => p.Item2 != null).FirstOrDefault(p => p.Item2!.Index == i).p;
                             if (arrayProp != null)
-                                CheckPropertyValue(method, item, arrayProp.GetValue(resultObj), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties);
+                                CheckPropertyValue(method, item, arrayProp.GetValue(resultObj), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties, outputExceptions);
 
                             i++;
                         }
@@ -290,9 +320,12 @@ namespace CryptoExchange.Net.Testing.Comparers
                     {
                         var value = enumerator.Current;
                         if (value == default && jToken.ValueKind != JsonValueKind.Null)
-                            throw new Exception($"{method}: Property `{propertyName}` has no value while input json `{propName}` has value {jToken}");
+                        {
+                            outputExceptions.Add(new Exception($"{method}: Property `{propertyName}` has no value while input json `{propName}` has value {jToken}"));
+                            return;
+                        }
 
-                        CheckValues(method, propertyName!, propertyType, jToken, value!);
+                        CheckValues(method, propertyName!, propertyType, jToken, value!, outputExceptions);
                     }
                 }
             }
@@ -307,7 +340,7 @@ namespace CryptoExchange.Net.Testing.Comparers
                             if (ignoreProperties?.Contains(item.Name) == true)
                                 continue;
 
-                            CheckObject(method, item, propertyValue, ignoreProperties);
+                            CheckObject(method, item, propertyValue, ignoreProperties, outputExceptions);
                         //}
                     }
                 }
@@ -328,7 +361,7 @@ namespace CryptoExchange.Net.Testing.Comparers
                                 {
                                     if (ignoreProperties?.Contains(subProp.Name) == true)
                                         continue;
-                                    CheckObject(method, subProp, enumerator.Current, ignoreProperties!);
+                                    CheckObject(method, subProp, enumerator.Current, ignoreProperties!, outputExceptions);
                                 }
                             }
                             else if (jObj.ValueKind == JsonValueKind.Array)
@@ -346,7 +379,7 @@ namespace CryptoExchange.Net.Testing.Comparers
                                 {
                                     var arrayProp = resultProps.SingleOrDefault(p => p.Item2!.Index == i).p;
                                     if (arrayProp != null)
-                                        CheckPropertyValue(method, item, arrayProp.GetValue(resultObj), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!);
+                                        CheckPropertyValue(method, item, arrayProp.GetValue(resultObj), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!, outputExceptions);
                                     i++;
                                 }
                             }
@@ -354,7 +387,10 @@ namespace CryptoExchange.Net.Testing.Comparers
                             {
                                 var value = enumerator.Current;
                                 if (value == default && jObj.ValueKind != JsonValueKind.Null)
-                                    throw new Exception($"{method}: Array has no value while input json array has value {jObj}");
+                                {
+                                    outputExceptions.Add(new Exception($"{method}: Array has no value while input json array has value {jObj}"));
+                                    continue;
+                                }
                             }
                         }
                     }
@@ -366,19 +402,19 @@ namespace CryptoExchange.Net.Testing.Comparers
                         {
                             var arrayProp = resultProps.Where(p => p.Item2 != null).FirstOrDefault(p => p.Item2!.Index == i).p;
                             if (arrayProp != null)
-                                CheckPropertyValue(method, item, arrayProp.GetValue(propertyValue), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!);
+                                CheckPropertyValue(method, item, arrayProp.GetValue(propertyValue), arrayProp.PropertyType, arrayProp.Name, "Array index " + i, ignoreProperties!, outputExceptions);
                             i++;
                         }
                     }
                 }
                 else
                 {
-                    CheckValues(method, propertyName!, propertyType, propValue, propertyValue);
+                    CheckValues(method, propertyName!, propertyType, propValue, propertyValue, outputExceptions);
                 }
             }
         }
 
-        private static void CheckValues(string method, string property, Type propertyType, JsonElement jsonValue, object objectValue)
+        private static void CheckValues(string method, string property, Type propertyType, JsonElement jsonValue, object objectValue, List<Exception> outputExceptions)
         {
             if (jsonValue.ValueKind == JsonValueKind.String)
             {
@@ -386,19 +422,19 @@ namespace CryptoExchange.Net.Testing.Comparers
                 if (objectValue is decimal dec)
                 {
                     if (ExchangeHelpers.ParseDecimal(stringValue!) != dec)
-                        throw new Exception($"{method}: {property} not equal: {stringValue} vs {dec}");
+                        outputExceptions.Add(new Exception($"{method}: {property} not equal: {stringValue} vs {dec}")   );
                 }
                 else if (objectValue is DateTime time)
                 {
                     if (!string.IsNullOrEmpty(stringValue) && time != DateTimeConverter.ParseFromString(stringValue!, null))
-                        throw new Exception($"{method}: {property} not equal: {stringValue} vs {time}");
+                        outputExceptions.Add(new Exception($"{method}: {property} not equal: {stringValue} vs {time}"));
                 }
                 else if (objectValue is bool bl)
                 {
                     if (bl && (stringValue != "1" && stringValue != "true" && stringValue != "True" && stringValue != "yes" && stringValue != "YES" && stringValue != "enabled"))
-                        throw new Exception($"{method}: {property} not equal: {stringValue} vs {bl}");
+                        outputExceptions.Add(new Exception($"{method}: {property} not equal: {stringValue} vs {bl}"));
                     if (!bl && (stringValue != "0" && stringValue != "-1" && stringValue != "false" && stringValue != "False" && stringValue != "no" && stringValue != "NO" && stringValue != "disabled"))
-                        throw new Exception($"{method}: {property} not equal: {stringValue} vs {bl}");
+                        outputExceptions.Add(new Exception($"{method}: {property} not equal: {stringValue} vs {bl}")    );
                 }
                 else if (propertyType.IsEnum || Nullable.GetUnderlyingType(propertyType)?.IsEnum == true)
                 {
@@ -406,7 +442,7 @@ namespace CryptoExchange.Net.Testing.Comparers
                 }
                 else if (!stringValue!.Equals(Convert.ToString(objectValue, CultureInfo.InvariantCulture), StringComparison.InvariantCultureIgnoreCase))
                 {
-                    throw new Exception($"{method}: {property} not equal: {stringValue} vs {objectValue}");
+                    outputExceptions.Add(new Exception($"{method}: {property} not equal: {stringValue} vs {objectValue}"));
                 }
             }
             else if (jsonValue.ValueKind == JsonValueKind.Number)
@@ -415,7 +451,7 @@ namespace CryptoExchange.Net.Testing.Comparers
                 if (objectValue is DateTime time)
                 {
                     if (time != DateTimeConverter.ParseFromDecimal(value))
-                        throw new Exception($"{method}: {property} not equal: {DateTimeConverter.ParseFromDouble((double)value!)} vs {time}");
+                        outputExceptions.Add(new Exception($"{method}: {property} not equal: {DateTimeConverter.ParseFromDouble((double)value!)} vs {time}"));
                 }
                 else if (propertyType.IsEnum || Nullable.GetUnderlyingType(propertyType)?.IsEnum == true)
                 {
@@ -424,27 +460,27 @@ namespace CryptoExchange.Net.Testing.Comparers
                 else if(objectValue is decimal dec)
                 {
                     if (dec != value)
-                        throw new Exception($"{method}: {property} not equal: {dec} vs {value}");
+                        outputExceptions.Add(new Exception($"{method}: {property} not equal: {dec} vs {value}"));
                 }
                 else if (objectValue is double dbl)
                 {
                     if ((decimal)dbl != value)
-                        throw new Exception($"{method}: {property} not equal: {dbl} vs {value}");
+                        outputExceptions.Add(new Exception($"{method}: {property} not equal: {dbl} vs {value}"));
                 }
                 else if(objectValue is string objStr)
                 {
                     if (objStr != value.ToString())
-                        throw new Exception($"{method}: {property} not equal: {value} vs {objStr}");
+                        outputExceptions.Add(new Exception($"{method}: {property} not equal: {value} vs {objStr}"));
                 }
                 else if (value != Convert.ToInt64(objectValue, CultureInfo.InvariantCulture))
                 {
-                    throw new Exception($"{method}: {property} not equal: {value} vs {Convert.ToInt64(objectValue)}");
+                    outputExceptions.Add(new Exception($"{method}: {property} not equal: {value} vs {Convert.ToInt64(objectValue)}"));
                 }
             }
             else if (jsonValue.ValueKind == JsonValueKind.True || jsonValue.ValueKind == JsonValueKind.False)
             {
                 if (jsonValue.GetBoolean() != (bool)objectValue)
-                    throw new Exception($"{method}: {property} not equal: {jsonValue.GetBoolean()} vs {(bool)objectValue}");
+                    outputExceptions.Add(new Exception($"{method}: {property} not equal: {jsonValue.GetBoolean()} vs {(bool)objectValue}"));
             }
         }
     }

CryptoExchange.Net/Testing/Exceptions/MissingPropertyException.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace CryptoExchange.Net.Testing.Exceptions
+{
+    internal class MissingPropertyException : Exception
+    {
+        public MissingPropertyException(string method, string objName, string propName, string value) 
+            : base($"{method}: Missing property `{propName}` on `{objName}`, value: {value.Substring(0, Math.Min(50, value.Length))}")
+        {
+        }
+    }
+}

CryptoExchange.Net/Testing/RestIntegrationTest.cs

@@ -1,10 +1,12 @@
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Testing.Comparers;
+using CryptoExchange.Net.Testing.Exceptions;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 
@@ -55,6 +57,26 @@ namespace CryptoExchange.Net.Testing
             return true;
         }
 
+        /// <summary>
+        /// Execute a REST endpoint call and check for any errors or warnings. Also checks for missing fields in the response mapping
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="warningExceptionsHolder">List for outputting warnings</param>
+        /// <param name="expression">The call expression</param>
+        /// <param name="authRequest">Whether this is an authenticated request</param>
+        /// <param name="compareNestedProperty">Nested property to use for comparing when checking for missing fields</param>
+        /// <param name="ignoreProperties">Properties to ignore when checking for missing fields</param>
+        /// <param name="useSingleArrayItem">Whether to use the single array item as compare when checking for missing fields</param>
+        /// <returns></returns>
+        public Task RunAndCheckResult<T>(
+            List<Exception> warningExceptionsHolder,
+            Expression<Func<TClient, Task<HttpResult<T>>>> expression,
+            bool authRequest,
+            string? compareNestedProperty = null,
+            List<string>? ignoreProperties = null,
+            bool? useSingleArrayItem = null)
+            => RunAndCheckResult(expression, authRequest, true, compareNestedProperty, ignoreProperties, useSingleArrayItem, warningExceptionsHolder);
+
         /// <summary>
         /// Execute a REST endpoint call and check for any errors or warnings.
         /// </summary>
@@ -65,13 +87,15 @@ namespace CryptoExchange.Net.Testing
         /// <param name="compareNestedProperty">Nested property to use for comparing when checking for missing fields</param>
         /// <param name="ignoreProperties">Properties to ignore when checking for missing fields</param>
         /// <param name="useSingleArrayItem">Whether to use the single array item as compare when checking for missing fields</param>
+        /// <param name="warnings">List for outputting warnings</param>
         public async Task RunAndCheckResult<T>(
             Expression<Func<TClient, Task<HttpResult<T>>>> expression,
             bool authRequest,
             bool checkMissingFields = false,
             string? compareNestedProperty = null,
             List<string>? ignoreProperties = null,
-            bool? useSingleArrayItem = null)
+            bool? useSingleArrayItem = null,
+            List<Exception>? warnings = null)
         {
             if (!ShouldRun())
                 return;
@@ -112,8 +136,25 @@ namespace CryptoExchange.Net.Testing
                 if (originalData == null)
                     throw new Exception($"Original data needs to be enabled in the client options to check for missing fields");
 
-                try {
-                    SystemTextJsonComparer.CompareData(expressionBody.Method.Name, data, originalData, compareNestedProperty, ignoreProperties, useSingleArrayItem ?? false);
+                var errors = new List<Exception>();
+                try 
+                {
+                    var issues = SystemTextJsonComparer.CompareData(expressionBody.Method.Name, data, originalData, compareNestedProperty, ignoreProperties, useSingleArrayItem ?? false);
+                    foreach(var issue in issues)
+                    {
+                        if (issue is MissingPropertyException)
+                        {
+                            if (!warnings?.Any(x => x.Message == issue.Message) == true)
+                                warnings?.Add(issue);
+                        }
+                        else
+                        {
+                            errors.Add(issue);
+                        }
+                    }
+
+                    if (errors.Count > 0)
+                        throw new AggregateException(errors);
                 }
                 catch (Exception ex)
                 {

CryptoExchange.Net/Testing/RestRequestValidator.cs

@@ -1,6 +1,7 @@
 using CryptoExchange.Net.Clients;
 using CryptoExchange.Net.Objects;
 using CryptoExchange.Net.Testing.Comparers;
+using CryptoExchange.Net.Testing.Exceptions;
 using System;
 using System.Collections.Generic;
 using System.Collections.Specialized;
@@ -184,7 +185,9 @@ namespace CryptoExchange.Net.Testing
             {
                 // Check response data
                 object responseData = (TActualResponse)result.Data!;
-                SystemTextJsonComparer.CompareData(name, responseData, response, nestedJsonProperty ?? _nestedPropertyForCompare, ignoreProperties, useSingleArrayItem);
+                var issues = SystemTextJsonComparer.CompareData(name, responseData, response, nestedJsonProperty ?? _nestedPropertyForCompare, ignoreProperties, useSingleArrayItem);
+                if (issues.Count > 0)
+                    throw new AggregateException(issues);
             }
 
             Trace.Listeners.Remove(listener);

CryptoExchange.Net/Testing/SocketRequestValidator.cs

@@ -155,7 +155,7 @@ namespace CryptoExchange.Net.Testing
                 else if (line.StartsWith("< "))
                 {
                     // Expect a message from server to client
-                    foreach(var item in replaceValues)
+                    foreach (var item in replaceValues)
                         line = line.Replace(item.Key, item.Value);
 
                     socket.InvokeMessage(line.Substring(2));
@@ -175,7 +175,11 @@ namespace CryptoExchange.Net.Testing
                         result = responseMapper(task.Result.Data!);
 
                     if (!skipResponseValidation)
-                        SystemTextJsonComparer.CompareData(name, result, compareData, nestedJsonProperty ?? _nestedPropertyForCompare, ignoreProperties, useSingleArrayItem);
+                    {
+                        var issues = SystemTextJsonComparer.CompareData(name, result, compareData, nestedJsonProperty ?? _nestedPropertyForCompare, ignoreProperties, useSingleArrayItem);
+                        if (issues.Count > 0)
+                            throw new AggregateException(issues);
+                    }
                 }
             }
 

CryptoExchange.Net/Testing/SocketSubscriptionValidator.cs

@@ -326,7 +326,11 @@ namespace CryptoExchange.Net.Testing
                         throw new Exception($"{name} Update send to client did not trigger in update handler");
 
                     if (skipUpdateValidation != true)
-                        SystemTextJsonComparer.CompareData(name, update, compareData, nestedJsonProperty ?? _nestedPropertyForCompare, ignoreProperties, useFirstUpdateItem ?? false);
+                    {
+                        var issues = SystemTextJsonComparer.CompareData(name, update, compareData, nestedJsonProperty ?? _nestedPropertyForCompare, ignoreProperties, useFirstUpdateItem ?? false);
+                        if (issues.Count > 0)
+                            throw new AggregateException(issues);
+                    }
                 }
             }
 

CryptoExchange.Net/Trackers/Klines/KlineTracker.cs

@@ -19,6 +19,7 @@ namespace CryptoExchange.Net.Trackers.Klines
         private readonly IKlineRestClient _restClient;
         private SyncStatus _status;
         private bool _startWithSnapshot;
+        private ExchangeParameters? _exchangeParameters;
 
         /// <summary>
         /// The internal data structure
@@ -157,9 +158,11 @@ namespace CryptoExchange.Net.Trackers.Klines
             SharedSymbol symbol,
             SharedKlineInterval interval,
             int? limit = null,
-            TimeSpan? period = null)
+            TimeSpan? period = null,
+            ExchangeParameters? exchangeParameters = null)
         {
             _logger = logger ?? new NullLogger<KlineTracker>();
+            _exchangeParameters = exchangeParameters;
             Symbol = symbol;
             SymbolName = socketClient.FormatSymbol(symbol.BaseAsset, symbol.QuoteAsset, symbol.TradingMode, symbol.DeliverTime);
             Exchange = restClient.Exchange;
@@ -180,7 +183,7 @@ namespace CryptoExchange.Net.Trackers.Klines
             Status = SyncStatus.Syncing;
             _logger.KlineTrackerStarting(SymbolName);
 
-            var subResult = await _socketClient.SubscribeToKlineUpdatesAsync(new SubscribeKlineRequest(Symbol, Interval),
+            var subResult = await _socketClient.SubscribeToKlineUpdatesAsync(new SubscribeKlineRequest(Symbol, Interval, exchangeParameters: _exchangeParameters),
                  update =>
                  {
                      AddOrUpdate(update.Data);
@@ -237,7 +240,7 @@ namespace CryptoExchange.Net.Trackers.Klines
 
             var limit = Math.Min(_restClient.GetKlinesOptions.MaxLimit, Limit ?? 100);
 
-            var request = new GetKlinesRequest(Symbol, Interval, startTime, DateTime.UtcNow, limit: limit);
+            var request = new GetKlinesRequest(Symbol, Interval, startTime, DateTime.UtcNow, limit: limit, exchangeParameters: _exchangeParameters);
             var data = new List<SharedKline>();
             await foreach (var result in ExchangeHelpers.ExecutePages(_restClient.GetKlinesAsync, request).ConfigureAwait(false))
             {
@@ -281,8 +284,10 @@ namespace CryptoExchange.Net.Trackers.Klines
                 LastOpenTime = klines.Last().OpenTime,
                 HighPrice = klines.Select(d => d.LowPrice).Max(),
                 LowPrice = klines.Select(d => d.HighPrice).Min(),
+#pragma warning disable CS0618 // Type or member is obsolete | Temporary to maintain previous behavior
                 Volume = klines.Select(d => d.Volume).Sum(),
                 AverageVolume = Math.Round(klines.OrderByDescending(d => d.OpenTime).Skip(1).Select(d => d.Volume).DefaultIfEmpty().Average(), 8)
+#pragma warning restore
             };
         }
 

CryptoExchange.Net/Trackers/Trades/TradeTracker.cs

@@ -21,6 +21,7 @@ namespace CryptoExchange.Net.Trackers.Trades
         private SyncStatus _status;
         private long _snapshotId;
         private bool _startWithSnapshot;
+        private ExchangeParameters? _exchangeParameters;
 
         /// <summary>
         /// The internal data structure
@@ -137,6 +138,11 @@ namespace CryptoExchange.Net.Trackers.Trades
             }
         }
 
+        /// <summary>
+        /// The type of quantity the trades and stats are denoted in
+        /// </summary>
+        public TradeQuantityType QuantityType { get; }
+
         /// <inheritdoc />
         public event Func<SharedTrade, Task>? OnAdded;
         /// <inheritdoc />
@@ -154,12 +160,16 @@ namespace CryptoExchange.Net.Trackers.Trades
             ITradeSocketClient socketClient,
             SharedSymbol symbol,
             int? limit = null,
-            TimeSpan? period = null)
+            TimeSpan? period = null,
+            TradeQuantityType tradeQuantityType = TradeQuantityType.BaseAsset,
+            ExchangeParameters? exchangeParameters = null)
         {
             _logger = logger ?? new NullLogger<TradeTracker>();
             _recentRestClient = recentRestClient;
             _historyRestClient = historyRestClient;
             _socketClient = socketClient;
+            QuantityType = tradeQuantityType;
+            _exchangeParameters = exchangeParameters;
             Exchange = socketClient.Exchange;
             Symbol = symbol;
             SymbolName = socketClient.FormatSymbol(symbol.BaseAsset, symbol.QuoteAsset, symbol.TradingMode, symbol.DeliverTime);
@@ -167,22 +177,41 @@ namespace CryptoExchange.Net.Trackers.Trades
             Period = period;
         }
 
-        private static TradesStats GetStats(IEnumerable<SharedTrade> trades)
+        private TradesStats GetStats(IEnumerable<SharedTrade> trades)
         {
             if (!trades.Any())
                 return new TradesStats();
 
-            return new TradesStats
+
+            var stats = new TradesStats
             {
                 TradeCount = trades.Count(),
                 FirstTradeTime = trades.First().Timestamp,
                 LastTradeTime = trades.Last().Timestamp,
                 AveragePrice = Math.Round(trades.Select(d => d.Price).DefaultIfEmpty().Average(), 8),                
-                VolumeWeightedAveragePrice = trades.Any() ? Math.Round(trades.Select(d => d.Price * d.Quantity).DefaultIfEmpty().Sum() / trades.Select(d => d.Quantity).DefaultIfEmpty().Sum(), 8) : null,
-                Volume = Math.Round(trades.Sum(d => d.Quantity), 8),
-                QuoteVolume = Math.Round(trades.Sum(d => d.Quantity * d.Price), 8),
-                BuySellRatio = Math.Round(trades.Where(x => x.Side == SharedOrderSide.Buy).Sum(x => x.Quantity) / trades.Sum(x => x.Quantity), 8)
+                QuoteVolume = Math.Round(trades.Sum(d => d.Quantities.GetQuantityInQuoteAsset(d.Price) ?? 0), 8),
             };
+
+            if (QuantityType == TradeQuantityType.BaseAsset)
+            {
+                stats.VolumeWeightedAveragePrice =
+                    trades.Any()
+                        ? Math.Round(trades.Select(d => d.Quantities.GetQuantityInQuoteAsset(d.Price) ?? 0).DefaultIfEmpty().Sum() / trades.Select(d => d.Quantities.QuantityInBaseAsset!.Value).DefaultIfEmpty().Sum(), 8)
+                        : null;
+                stats.Volume = Math.Round(trades.Sum(d => d.Quantities.QuantityInBaseAsset!.Value), 8);
+                stats.BuySellRatio = Math.Round(trades.Where(x => x.Side == SharedOrderSide.Buy).Sum(x => x.Quantities.QuantityInBaseAsset!.Value) / trades.Sum(x => x.Quantities.QuantityInBaseAsset!.Value), 8);
+            }
+            else
+            {
+                stats.VolumeWeightedAveragePrice =
+                    trades.Any()
+                        ? Math.Round(trades.Select(d => d.Quantities.GetQuantityInQuoteAsset(d.Price) ?? 0).DefaultIfEmpty().Sum() / trades.Select(d => d.Quantities.QuantityInContracts!.Value).DefaultIfEmpty().Sum(), 8)
+                        : null;
+                stats.Volume = Math.Round(trades.Sum(d => d.Quantities.QuantityInContracts!.Value), 8);
+                stats.BuySellRatio = Math.Round(trades.Where(x => x.Side == SharedOrderSide.Buy).Sum(x => x.Quantities.QuantityInContracts!.Value) / trades.Sum(x => x.Quantities.QuantityInContracts!.Value), 8);
+            }
+
+            return stats;
         }
 
         /// <inheritdoc />
@@ -203,7 +232,7 @@ namespace CryptoExchange.Net.Trackers.Trades
             _startWithSnapshot = startWithSnapshot;
             Status = SyncStatus.Syncing;
             _logger.TradeTrackerStarting(SymbolName);
-            var subResult = await _socketClient.SubscribeToTradeUpdatesAsync(new SubscribeTradeRequest(Symbol),
+            var subResult = await _socketClient.SubscribeToTradeUpdatesAsync(new SubscribeTradeRequest(Symbol, exchangeParameters: _exchangeParameters),
                  update =>
                  {
                      AddData(update.Data);
@@ -257,7 +286,7 @@ namespace CryptoExchange.Net.Trackers.Trades
             if (_historyRestClient != null)
             {
                 var startTime = Period == null ? DateTime.UtcNow.AddMinutes(-5) : DateTime.UtcNow.Add(-Period.Value);
-                var request = new GetTradeHistoryRequest(Symbol, startTime, DateTime.UtcNow);
+                var request = new GetTradeHistoryRequest(Symbol, startTime, DateTime.UtcNow, exchangeParameters: _exchangeParameters);
                 var data = new List<SharedTrade>();
                 await foreach (var result in ExchangeHelpers.ExecutePages(_historyRestClient.GetTradeHistoryAsync, request).ConfigureAwait(false))
                 {
@@ -278,7 +307,7 @@ namespace CryptoExchange.Net.Trackers.Trades
                 if (Limit.HasValue)
                     limit = Math.Min(_recentRestClient.GetRecentTradesOptions.MaxLimit, Limit.Value);
 
-                var snapshot = await _recentRestClient.GetRecentTradesAsync(new GetRecentTradesRequest(Symbol, limit)).ConfigureAwait(false);
+                var snapshot = await _recentRestClient.GetRecentTradesAsync(new GetRecentTradesRequest(Symbol, limit, exchangeParameters: _exchangeParameters)).ConfigureAwait(false);
                 if (!snapshot.Success)
                 {
                     return CallResult.Fail(snapshot.Error);
@@ -495,4 +524,19 @@ namespace CryptoExchange.Net.Trackers.Trades
                 Status = SyncStatus.Synced;
         }
     }
+
+    /// <summary>
+    /// The quantities to use for trade tracking
+    /// </summary>
+    public enum TradeQuantityType
+    {
+        /// <summary>
+        /// Base asset
+        /// </summary>
+        BaseAsset,
+        /// <summary>
+        /// Contracts
+        /// </summary>
+        Contracts
+    }
 }

Examples/BlazorClient/BlazorClient.csproj

@@ -5,33 +5,36 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Binance.Net" Version="12.13.0" />
-    <PackageReference Include="Bitfinex.Net" Version="10.12.0" />
-    <PackageReference Include="BitMart.Net" Version="3.11.2" />
-    <PackageReference Include="BloFin.Net" Version="2.11.0" />
-    <PackageReference Include="Bybit.Net" Version="6.13.0" />
-    <PackageReference Include="CoinEx.Net" Version="10.11.0" />
-    <PackageReference Include="CoinW.Net" Version="2.10.0" />
-    <PackageReference Include="CryptoCom.Net" Version="3.11.0" />
-    <PackageReference Include="DeepCoin.Net" Version="3.10.0" />
-    <PackageReference Include="GateIo.Net" Version="3.11.0" />
-    <PackageReference Include="HyperLiquid.Net" Version="4.7.1" />
-    <PackageReference Include="JK.BingX.Net" Version="3.11.1" />
-    <PackageReference Include="JK.Bitget.Net" Version="3.12.1" />
-    <PackageReference Include="JK.Mexc.Net" Version="5.2.0" />
-    <PackageReference Include="JK.OKX.Net" Version="4.14.0" />
-    <PackageReference Include="Jkorf.Aster.Net" Version="3.3.0" />
-    <PackageReference Include="JKorf.BitMEX.Net" Version="3.10.0" />
-    <PackageReference Include="JKorf.Coinbase.Net" Version="3.10.1" />
-    <PackageReference Include="JKorf.HTX.Net" Version="8.10.1" />
-    <PackageReference Include="JKorf.Upbit.Net" Version="2.10.1" />
-    <PackageReference Include="KrakenExchange.Net" Version="7.11.0" />
-    <PackageReference Include="Kucoin.Net" Version="8.13.0" />
+    <PackageReference Include="Binance.Net" Version="13.3.0" />
+    <PackageReference Include="Bitfinex.Net" Version="11.3.0" />
+    <PackageReference Include="BitMart.Net" Version="4.3.0" />
+    <PackageReference Include="BloFin.Net" Version="3.3.0" />
+    <PackageReference Include="Bybit.Net" Version="7.3.0" />
+    <PackageReference Include="CoinEx.Net" Version="11.3.0" />
+    <PackageReference Include="CoinW.Net" Version="3.3.0" />
+    <PackageReference Include="CryptoCom.Net" Version="4.3.0" />
+    <PackageReference Include="DeepCoin.Net" Version="4.3.0" />
+    <PackageReference Include="GateIo.Net" Version="4.4.0" />
+    <PackageReference Include="HyperLiquid.Net" Version="5.4.0" />
+    <PackageReference Include="JK.BingX.Net" Version="4.3.0" />
+    <PackageReference Include="JK.Bitget.Net" Version="4.3.2" />
+    <PackageReference Include="JK.Mexc.Net" Version="6.4.0" />
+    <PackageReference Include="JK.OKX.Net" Version="5.3.1" />
+    <PackageReference Include="Jkorf.Aster.Net" Version="4.3.0" />
+    <PackageReference Include="JKorf.BitMEX.Net" Version="4.3.0" />
+    <PackageReference Include="JKorf.Coinbase.Net" Version="4.4.0" />
+    <PackageReference Include="JKorf.HTX.Net" Version="9.3.0" />
+    <PackageReference Include="JKorf.Lighter.Net" Version="1.4.0" />
+    <PackageReference Include="JKorf.Upbit.Net" Version="3.3.0" />
+    <PackageReference Include="KrakenExchange.Net" Version="8.3.0" />
+    <PackageReference Include="Kucoin.Net" Version="9.3.0" />
+    <PackageReference Include="LBank.Net" Version="1.0.0" />
+    <PackageReference Include="Pionex.Net" Version="1.1.0" />
     <PackageReference Include="Serilog.AspNetCore" Version="10.0.0" />
-    <PackageReference Include="Toobit.Net" Version="3.10.0" />
-    <PackageReference Include="Weex.Net" Version="1.1.1" />
-    <PackageReference Include="WhiteBit.Net" Version="3.11.1" />
-    <PackageReference Include="XT.Net" Version="3.10.0" />
+    <PackageReference Include="Toobit.Net" Version="4.3.0" />
+    <PackageReference Include="Weex.Net" Version="2.3.0" />
+    <PackageReference Include="WhiteBit.Net" Version="4.3.0" />
+    <PackageReference Include="XT.Net" Version="4.3.0" />
   </ItemGroup>
 
 </Project>

Examples/BlazorClient/Pages/Index.razor

@@ -18,8 +18,11 @@
 @inject IHyperLiquidRestClient hyperLiquidClient
 @inject IKrakenRestClient krakenClient
 @inject IKucoinRestClient kucoinClient
+@inject ILBankRestClient lbankClient
+@inject ILighterRestClient lighterClient
 @inject IMexcRestClient mexcClient
 @inject IOKXRestClient okxClient
+@inject IPionexRestClient pionexClient
 @inject IToobitRestClient toobitClient
 @inject IUpbitRestClient upbitClient
 @inject IWeexRestClient weexClient
@@ -40,7 +43,7 @@
         var asterTask = asterClient.SpotApi.ExchangeData.GetTickerAsync("BTCUSDT");
         var binanceTask = binanceClient.SpotApi.ExchangeData.GetTickerAsync("BTCUSDT");
         var bingXTask = bingXClient.SpotApi.ExchangeData.GetTickersAsync("BTC-USDT");
-        var bitfinexTask = bitfinexClient.SpotApi.ExchangeData.GetTickerAsync("tBTCUSD");
+        var bitfinexTask = bitfinexClient.ExchangeApi.ExchangeData.GetTickerAsync("tBTCUSD");
         var bitgetTask = bitgetClient.SpotApiV2.ExchangeData.GetTickersAsync("BTCUSDT");
         var bitmartTask = bitmartClient.SpotApi.ExchangeData.GetTickerAsync("BTC_USDT");
         var bitmexTask = bitmexClient.ExchangeApi.ExchangeData.GetSymbolsAsync("XBT_USDT");
@@ -56,15 +59,18 @@
         var hyperLiquidTask = hyperLiquidClient.FuturesApi.ExchangeData.GetExchangeInfoAndTickersAsync();
         var krakenTask = krakenClient.SpotApi.ExchangeData.GetTickerAsync("XBTUSD");
         var kucoinTask = kucoinClient.SpotApi.ExchangeData.GetTickerAsync("BTC-USDT");
+        var lBankTask = lbankClient.SpotApi.ExchangeData.GetTickersAsync("btc_usdt");
+        var lighterTask = lighterClient.ExchangeApi.ExchangeData.GetSymbolDetailsAsync("BTC");
         var mexcTask = mexcClient.SpotApi.ExchangeData.GetTickerAsync("BTCUSDT");
         var okxTask = okxClient.UnifiedApi.ExchangeData.GetTickerAsync("BTC-USDT");
+        var pionexTask = pionexClient.SpotApi.ExchangeData.GetTickersAsync("BTC_USDT");
         var toobitTask = toobitClient.SpotApi.ExchangeData.GetTickersAsync("BTCUSDT");
         var upbitTask = upbitClient.SpotApi.ExchangeData.GetTickerAsync("USDT-BTC");
         var weexTask = weexClient.SpotApi.ExchangeData.GetTickersAsync(["BTCUSDT"]);
         var whitebitTask = whitebitClient.V4Api.ExchangeData.GetTickersAsync();
         var xtTask = xtClient.SpotApi.ExchangeData.GetTickersAsync("btc_usdt");
 
-        await Task.WhenAll(asterTask, binanceTask, bingXTask, bitfinexTask, bitgetTask, bitmartTask, bloFinTask, bitmexTask, bybitTask, coinexTask, coinWTask, deepCoinTask, gateioTask, htxTask, krakenTask, kucoinTask, mexcTask, okxTask);
+        await Task.WhenAll(asterTask, binanceTask, bingXTask, bitfinexTask, bitgetTask, bitmartTask, bloFinTask, bitmexTask, bybitTask, coinexTask, coinWTask, deepCoinTask, gateioTask, htxTask, krakenTask, kucoinTask, lBankTask, mexcTask, okxTask, pionexTask);
 
         if (asterTask.Result.Success)
             _prices.Add("Aster", asterTask.Result.Data.LastPrice);
@@ -131,12 +137,21 @@
         if (kucoinTask.Result.Success)
             _prices.Add("Kucoin", kucoinTask.Result.Data.LastPrice ?? 0);
 
+        if (lBankTask.Result.Success)
+            _prices.Add("LBank", lBankTask.Result.Data.Single().Ticker.LastPrice);
+
+        if (lighterTask.Result.Success)
+            _prices.Add("Lighter", lighterTask.Result.Data.PerpSymbols[0].LastPrice);
+
         if (mexcTask.Result.Success)
             _prices.Add("Mexc", mexcTask.Result.Data.LastPrice);
 
         if (okxTask.Result.Success)
             _prices.Add("OKX", okxTask.Result.Data.LastPrice ?? 0);
 
+        if (pionexTask.Result.Success)
+            _prices.Add("Pionex", pionexTask.Result.Data.Single().ClosePrice);
+
         if (toobitTask.Result.Success)
             _prices.Add("Toobit", toobitTask.Result.Data.Single().LastPrice ?? 0);
 

Examples/BlazorClient/Pages/LiveData.razor

@@ -18,8 +18,11 @@
 @inject IHyperLiquidSocketClient hyperLiquidSocketClient
 @inject IKrakenSocketClient krakenSocketClient
 @inject IKucoinSocketClient kucoinSocketClient
+@inject ILBankSocketClient lBankSocketClient
+@inject ILighterSocketClient lighterSocketClient
 @inject IMexcSocketClient mexcSocketClient
 @inject IOKXSocketClient okxSocketClient
+@inject IPionexSocketClient pionexSocketClient
 @inject IToobitSocketClient toobitSocketClient
 @inject IUpbitSocketClient upbitSocketClient
 @inject IWeexSocketClient weexSocketClient
@@ -44,13 +47,13 @@
 
     protected override async Task OnInitializedAsync()
     {
-        var tasks = new Task<CallResult<UpdateSubscription>>[]
+        var tasks = new Task<WebSocketResult<UpdateSubscription>>[]
         {
             // Aster doesn't support the ETH/BTC pair
             //asterSocketClient.SpotApi.ExchangeData.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("Aster", data.Data.LastPrice)),
             binanceSocketClient.SpotApi.ExchangeData.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("Binance", data.Data.LastPrice)),
             bingXSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETH-BTC", data => UpdateData("BingX", data.Data.LastPrice)),
-            bitfinexSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("tETHBTC", data => UpdateData("Bitfinex", data.Data.LastPrice)),
+            bitfinexSocketClient.ExchangeApi.SubscribeToTickerUpdatesAsync("tETHBTC", data => UpdateData("Bitfinex", data.Data.LastPrice)),
             bitgetSocketClient.SpotApiV2.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("Bitget", data.Data.First().LastPrice)),
             bitmartSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETH_BTC", data => UpdateData("BitMart", data.Data.LastPrice)),
             bitmexSocketClient.ExchangeApi.SubscribeToSymbolUpdatesAsync("ETH_XBT", data => UpdateData("BitMEX", data.Data.LastPrice ?? 0)),
@@ -64,11 +67,11 @@
             deepCoinSocketClient.ExchangeApi.SubscribeToSymbolUpdatesAsync("ETH-BTC", data => UpdateData("DeepCoin", data.Data.LastPrice ?? 0)),
             gateioSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETH_BTC", data => UpdateData("GateIo", data.Data.LastPrice)),
             htxSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ethbtc", data => UpdateData("HTX", data.Data.ClosePrice ?? 0)),
-            xtSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("eth_btc", data => UpdateData("XT", data.Data.LastPrice ?? 0)),
             // HyperLiquid doesn't support the ETH/BTC pair
             //hyperLiquidSocketClient.SpotApi.SubscribeToSymbolUpdatesAsync("ETH", data => UpdateData("HyperLiquid", data.Data.MidPrice ?? 0)),
             krakenSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETH/BTC", data => UpdateData("Kraken", data.Data.LastPrice)),
             kucoinSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETH-BTC", data => UpdateData("Kucoin", data.Data.LastPrice ?? 0)),
+            lBankSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("eth_btc", data => UpdateData("LBank", data.Data.LastPrice)),
             // Mexc doesn't offer a ticker stream currently
             //mexcSocketClient.SpotApi.SubscribeToMiniTickerUpdatesAsync("ETHBTC", data => UpdateData("Mexc", data.Data.LastPrice)),
             okxSocketClient.UnifiedApi.ExchangeData.SubscribeToTickerUpdatesAsync("ETH-BTC", data => UpdateData("OKX", data.Data.LastPrice ?? 0)),
@@ -76,6 +79,7 @@
             //toobitSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("ETHBTC", data => UpdateData("Toobit", data.Data.LastPrice ?? 0)),
             upbitSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("BTC-ETH", data => UpdateData("Upbit", data.Data.LastPrice)),
             whitebitSocketClient.V4Api.SubscribeToTickerUpdatesAsync("ETH_BTC", data => UpdateData("WhiteBit", data.Data.Ticker.LastPrice)),
+            xtSocketClient.SpotApi.SubscribeToTickerUpdatesAsync("eth_btc", data => UpdateData("XT", data.Data.LastPrice ?? 0)),
         };
 
         await Task.WhenAll(tasks);

Examples/BlazorClient/Pages/OrderBooks.razor

@@ -24,8 +24,11 @@
 @using Kucoin.Net
 @using Kucoin.Net.Clients
 @using Kucoin.Net.Interfaces
+@using LBank.Net.Interfaces
+@using Lighter.Net.Interfaces
 @using Mexc.Net.Interfaces
 @using OKX.Net.Interfaces;
+@using Pionex.Net.Interfaces;
 @using Upbit.Net.Interfaces;
 @using Toobit.Net.Interfaces;
 @using Weex.Net.Interfaces
@@ -50,8 +53,11 @@
 @inject IHyperLiquidOrderBookFactory hyperLiquidFactory
 @inject IKrakenOrderBookFactory krakenFactory
 @inject IKucoinOrderBookFactory kucoinFactory
+@inject ILBankOrderBookFactory lBankFactory
+@inject ILighterOrderBookFactory lighterFactory
 @inject IMexcOrderBookFactory mexcFactory
 @inject IOKXOrderBookFactory okxFactory
+@inject IPionexOrderBookFactory pionexFactory
 @inject IToobitOrderBookFactory toobitFactory
 @inject IUpbitOrderBookFactory upbitFactory
 @inject IWeexOrderBookFactory weexFactory
@@ -110,8 +116,11 @@
                 { "HyperLiquid", hyperLiquidFactory.Create("UETH/USDC") },
                 { "Kraken", krakenFactory.CreateSpot("ETH/BTC") },
                 { "Kucoin", kucoinFactory.CreateSpot("ETH-BTC") },
+                { "LBank", lBankFactory.CreateSpot("eth_usdt") },
+                { "Lighter", lighterFactory.Create("ETH/USDC") },
                 { "Mexc", mexcFactory.CreateSpot("ETHBTC") },
                 { "OKX", okxFactory.Create("ETH-BTC") },
+                { "Pionex", pionexFactory.CreateSpot("ETH_USDT") },
                 { "Toobit", toobitFactory.CreateSpot("ETHUSDT") },
                 { "Upbit", upbitFactory.CreateSpot("BTC-ETH") },
                 { "Weex", weexFactory.CreateSpot("ETHUSDT") },

Examples/BlazorClient/Pages/Trackers.razor

@@ -24,8 +24,11 @@
 @using Kraken.Net.Interfaces
 @using Kucoin.Net.Clients
 @using Kucoin.Net.Interfaces
+@using LBank.Net.Interfaces
+@using Lighter.Net.Interfaces
 @using Mexc.Net.Interfaces
 @using OKX.Net.Interfaces;
+@using Pionex.Net.Interfaces;
 @using Upbit.Net.Interfaces;
 @using Toobit.Net.Interfaces;
 @using Weex.Net.Interfaces
@@ -50,8 +53,11 @@
 @inject IHyperLiquidTrackerFactory hyperLiquidFactory
 @inject IKrakenTrackerFactory krakenFactory
 @inject IKucoinTrackerFactory kucoinFactory
+@inject ILBankTrackerFactory lBankFactory
+@inject ILighterTrackerFactory lighterFactory
 @inject IMexcTrackerFactory mexcFactory
 @inject IOKXTrackerFactory okxFactory
+@inject IPionexTrackerFactory pionexFactory
 @inject IToobitTrackerFactory toobitFactory
 @inject IUpbitTrackerFactory upbitFactory
 @inject IWeexTrackerFactory weexFactory
@@ -103,8 +109,11 @@
                 { hyperLiquidFactory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5)) },
                 { krakenFactory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5)) },
                 { kucoinFactory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5)) },
+                { lBankFactory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5)) },
+                { lighterFactory.CreateTradeTracker(futuresSymbol, period: TimeSpan.FromMinutes(5)) },
                 { mexcFactory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5)) },
                 { okxFactory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5)) },
+                { pionexFactory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5)) },
                 { toobitFactory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5)) },
                 { upbitFactory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5)) },
                 { weexFactory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5)) },

Examples/BlazorClient/Startup.cs

@@ -52,8 +52,11 @@ namespace BlazorClient
             services.AddHTX();
             services.AddKraken();
             services.AddKucoin();
+            services.AddLBank();
+            services.AddLighter();
             services.AddMexc();
             services.AddOKX();
+            services.AddPionex();
             services.AddToobit();
             services.AddUpbit();
             services.AddWeex();

Examples/BlazorClient/_Imports.razor

@@ -27,8 +27,11 @@
 @using HyperLiquid.Net.Interfaces.Clients;
 @using Kraken.Net.Interfaces.Clients;
 @using Kucoin.Net.Interfaces.Clients;
+@using LBank.Net.Interfaces.Clients
+@using Lighter.Net.Interfaces.Clients
 @using Mexc.Net.Interfaces.Clients;
 @using OKX.Net.Interfaces.Clients;
+@using Pionex.Net.Interfaces.Clients;
 @using Upbit.Net.Interfaces.Clients;
 @using Toobit.Net.Interfaces.Clients;
 @using Weex.Net.Interfaces.Clients

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 Jan Korf
+Copyright (c) 2026 JKorf
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

docs/README.md

@@ -1 +0,0 @@
-Source for https://jkorf.github.io/CryptoExchange.Net

docs/_config.yml

@@ -1,2 +0,0 @@
-remote_theme: pmarsceill/just-the-docs
-markdown: GFM

docs/assets/css/color-blue.css

@@ -1,159 +0,0 @@
-/*============================
-		COLOR Blue
-==============================*/
-::selection {
-  background: #007bff;
-}
-
-a, a:focus {
-  color: #007bff;
-}
-
-a:hover, a:active {
-  color: #006adb;
-}
-
-.primary-menu ul.navbar-nav > li:hover > a:not(.btn), .primary-menu ul.navbar-nav > li > a.active:not(.btn) {
-  color: #007bff;
-}
-.primary-menu ul.navbar-nav > li.dropdown .dropdown-menu li:hover > a:not(.btn) {
-  color: #007bff;
-}
-.primary-menu.navbar-line-under-text ul.navbar-nav > li > a:not(.btn):after {
-  border-color: #007bff;
-}
-
-/*=== Side Navigation ===*/
-.idocs-navigation .nav .nav .nav-item .nav-link.active:after, .idocs-navigation.docs-navigation-dark .nav .nav .nav-item .nav-link.active:after {
-  border-color: #007bff;
-}
-
-/* Accordion & Toggle */
-.accordion .card-header a:hover.collapsed {
-  color: #007bff !important;
-}
-.accordion:not(.accordion-alternate) .card-header a {
-  background-color: #007bff;
-  color: #fff;
-}
-
-/* Nav */
-.nav:not(.nav-pills) .nav-item .nav-link.active, .nav:not(.nav-pills) .nav-item .nav-link:hover {
-  color: #007bff;
-}
-
-.nav-tabs .nav-item .nav-link.active {
-  color: #0c2f55;
-}
-.nav-tabs .nav-item .nav-link.active:after {
-  background-color: #007bff;
-}
-.nav-tabs .nav-item .nav-link:not(.active):hover {
-  color: #007bff;
-}
-.nav-tabs.flex-column .nav-item .nav-link.active {
-  color: #007bff;
-}
-
-.nav-pills .nav-link:not(.active):hover {
-  color: #007bff;
-}
-
-#footer .nav .nav-item .nav-link:focus {
-  color: #007bff;
-}
-#footer .nav .nav-link:hover {
-  color: #007bff;
-}
-#footer .footer-copyright .nav .nav-link:hover {
-  color: #007bff;
-}
-
-/* Back to Top */
-#back-to-top:hover {
-  background-color: #007bff;
-}
-
-/* Extras */
-.bg-primary, .badge-primary {
-  background-color: #007bff !important;
-}
-
-.text-primary, .btn-light, .btn-outline-light:hover, .btn-link, .btn-outline-light:not(:disabled):not(.disabled).active, .btn-outline-light:not(:disabled):not(.disabled):active {
-  color: #007bff !important;
-}
-
-.btn-link:hover {
-  color: #006adb !important;
-}
-
-.text-muted {
-  color: #8e9a9d !important;
-}
-
-.text-light {
-  color: #dee3e4 !important;
-}
-
-a.bg-primary:focus, a.bg-primary:hover, button.bg-primary:focus, button.bg-primary:hover {
-  background-color: #006adb !important;
-}
-
-.border-primary {
-  border-color: #007bff !important;
-}
-
-.btn-primary {
-  background-color: #007bff;
-  border-color: #007bff;
-}
-.btn-primary:hover {
-  background-color: #006adb;
-  border-color: #006adb;
-}
-
-.btn-primary:not(:disabled):not(.disabled).active, .btn-primary:not(:disabled):not(.disabled):active {
-  background-color: #006adb;
-  border-color: #006adb;
-}
-
-.btn-primary.focus, .btn-primary:focus {
-  background-color: #006adb;
-  border-color: #006adb;
-}
-
-.btn-outline-primary, .btn-outline-primary:not(:disabled):not(.disabled).active, .btn-outline-primary:not(:disabled):not(.disabled):active {
-  color: #007bff;
-  border-color: #007bff;
-}
-.btn-outline-primary:hover, .btn-outline-primary:not(:disabled):not(.disabled).active:hover, .btn-outline-primary:not(:disabled):not(.disabled):active:hover {
-  background-color: #007bff;
-  border-color: #007bff;
-  color: #fff;
-}
-
-.progress-bar,
-.nav-pills .nav-link.active, .nav-pills .show > .nav-link, .dropdown-item.active, .dropdown-item:active {
-  background-color: #007bff;
-}
-
-.page-item.active .page-link,
-.custom-radio .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label::before,
-.custom-checkbox .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label:before {
-  background-color: #007bff;
-  border-color: #007bff;
-}
-
-.list-group-item.active {
-  background-color: #007bff;
-  border-color: #007bff;
-}
-
-.page-link {
-  color: #007bff;
-}
-.page-link:hover {
-  color: #006adb;
-}

docs/assets/css/color-brown.css

@@ -1,159 +0,0 @@
-/*============================
-		COLOR Brown
-==============================*/
-::selection {
-  background: #795548;
-}
-
-a, a:focus {
-  color: #795548;
-}
-
-a:hover, a:active {
-  color: #63453b;
-}
-
-.primary-menu ul.navbar-nav > li:hover > a:not(.btn), .primary-menu ul.navbar-nav > li > a.active:not(.btn) {
-  color: #795548;
-}
-.primary-menu ul.navbar-nav > li.dropdown .dropdown-menu li:hover > a:not(.btn) {
-  color: #795548;
-}
-.primary-menu.navbar-line-under-text ul.navbar-nav > li > a:not(.btn):after {
-  border-color: #795548;
-}
-
-/*=== Side Navigation ===*/
-.idocs-navigation .nav .nav .nav-item .nav-link.active:after, .idocs-navigation.docs-navigation-dark .nav .nav .nav-item .nav-link.active:after {
-  border-color: #795548;
-}
-
-/* Accordion & Toggle */
-.accordion .card-header a:hover.collapsed {
-  color: #795548 !important;
-}
-.accordion:not(.accordion-alternate) .card-header a {
-  background-color: #795548;
-  color: #fff;
-}
-
-/* Nav */
-.nav:not(.nav-pills) .nav-item .nav-link.active, .nav:not(.nav-pills) .nav-item .nav-link:hover {
-  color: #795548;
-}
-
-.nav-tabs .nav-item .nav-link.active {
-  color: #0c2f55;
-}
-.nav-tabs .nav-item .nav-link.active:after {
-  background-color: #795548;
-}
-.nav-tabs .nav-item .nav-link:not(.active):hover {
-  color: #795548;
-}
-.nav-tabs.flex-column .nav-item .nav-link.active {
-  color: #795548;
-}
-
-.nav-pills .nav-link:not(.active):hover {
-  color: #795548;
-}
-
-#footer .nav .nav-item .nav-link:focus {
-  color: #795548;
-}
-#footer .nav .nav-link:hover {
-  color: #795548;
-}
-#footer .footer-copyright .nav .nav-link:hover {
-  color: #795548;
-}
-
-/* Back to Top */
-#back-to-top:hover {
-  background-color: #795548;
-}
-
-/* Extras */
-.bg-primary, .badge-primary {
-  background-color: #795548 !important;
-}
-
-.text-primary, .btn-light, .btn-outline-light:hover, .btn-link, .btn-outline-light:not(:disabled):not(.disabled).active, .btn-outline-light:not(:disabled):not(.disabled):active {
-  color: #795548 !important;
-}
-
-.btn-link:hover {
-  color: #63453b !important;
-}
-
-.text-muted {
-  color: #8e9a9d !important;
-}
-
-.text-light {
-  color: #dee3e4 !important;
-}
-
-a.bg-primary:focus, a.bg-primary:hover, button.bg-primary:focus, button.bg-primary:hover {
-  background-color: #63453b !important;
-}
-
-.border-primary {
-  border-color: #795548 !important;
-}
-
-.btn-primary {
-  background-color: #795548;
-  border-color: #795548;
-}
-.btn-primary:hover {
-  background-color: #63453b;
-  border-color: #63453b;
-}
-
-.btn-primary:not(:disabled):not(.disabled).active, .btn-primary:not(:disabled):not(.disabled):active {
-  background-color: #63453b;
-  border-color: #63453b;
-}
-
-.btn-primary.focus, .btn-primary:focus {
-  background-color: #63453b;
-  border-color: #63453b;
-}
-
-.btn-outline-primary, .btn-outline-primary:not(:disabled):not(.disabled).active, .btn-outline-primary:not(:disabled):not(.disabled):active {
-  color: #795548;
-  border-color: #795548;
-}
-.btn-outline-primary:hover, .btn-outline-primary:not(:disabled):not(.disabled).active:hover, .btn-outline-primary:not(:disabled):not(.disabled):active:hover {
-  background-color: #795548;
-  border-color: #795548;
-  color: #fff;
-}
-
-.progress-bar,
-.nav-pills .nav-link.active, .nav-pills .show > .nav-link, .dropdown-item.active, .dropdown-item:active {
-  background-color: #795548;
-}
-
-.page-item.active .page-link,
-.custom-radio .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label::before,
-.custom-checkbox .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label:before {
-  background-color: #795548;
-  border-color: #795548;
-}
-
-.list-group-item.active {
-  background-color: #795548;
-  border-color: #795548;
-}
-
-.page-link {
-  color: #795548;
-}
-.page-link:hover {
-  color: #63453b;
-}

docs/assets/css/color-cyan.css

@@ -1,159 +0,0 @@
-/*============================
-		COLOR Cyan
-==============================*/
-::selection {
-  background: #17a2b8;
-}
-
-a, a:focus {
-  color: #17a2b8;
-}
-
-a:hover, a:active {
-  color: #138698;
-}
-
-.primary-menu ul.navbar-nav > li:hover > a:not(.btn), .primary-menu ul.navbar-nav > li > a.active:not(.btn) {
-  color: #17a2b8;
-}
-.primary-menu ul.navbar-nav > li.dropdown .dropdown-menu li:hover > a:not(.btn) {
-  color: #17a2b8;
-}
-.primary-menu.navbar-line-under-text ul.navbar-nav > li > a:not(.btn):after {
-  border-color: #17a2b8;
-}
-
-/*=== Side Navigation ===*/
-.idocs-navigation .nav .nav .nav-item .nav-link.active:after, .idocs-navigation.docs-navigation-dark .nav .nav .nav-item .nav-link.active:after {
-  border-color: #17a2b8;
-}
-
-/* Accordion & Toggle */
-.accordion .card-header a:hover.collapsed {
-  color: #17a2b8 !important;
-}
-.accordion:not(.accordion-alternate) .card-header a {
-  background-color: #17a2b8;
-  color: #fff;
-}
-
-/* Nav */
-.nav:not(.nav-pills) .nav-item .nav-link.active, .nav:not(.nav-pills) .nav-item .nav-link:hover {
-  color: #17a2b8;
-}
-
-.nav-tabs .nav-item .nav-link.active {
-  color: #0c2f55;
-}
-.nav-tabs .nav-item .nav-link.active:after {
-  background-color: #17a2b8;
-}
-.nav-tabs .nav-item .nav-link:not(.active):hover {
-  color: #17a2b8;
-}
-.nav-tabs.flex-column .nav-item .nav-link.active {
-  color: #17a2b8;
-}
-
-.nav-pills .nav-link:not(.active):hover {
-  color: #17a2b8;
-}
-
-#footer .nav .nav-item .nav-link:focus {
-  color: #17a2b8;
-}
-#footer .nav .nav-link:hover {
-  color: #17a2b8;
-}
-#footer .footer-copyright .nav .nav-link:hover {
-  color: #17a2b8;
-}
-
-/* Back to Top */
-#back-to-top:hover {
-  background-color: #17a2b8;
-}
-
-/* Extras */
-.bg-primary, .badge-primary {
-  background-color: #17a2b8 !important;
-}
-
-.text-primary, .btn-light, .btn-outline-light:hover, .btn-link, .btn-outline-light:not(:disabled):not(.disabled).active, .btn-outline-light:not(:disabled):not(.disabled):active {
-  color: #17a2b8 !important;
-}
-
-.btn-link:hover {
-  color: #138698 !important;
-}
-
-.text-muted {
-  color: #8e9a9d !important;
-}
-
-.text-light {
-  color: #dee3e4 !important;
-}
-
-a.bg-primary:focus, a.bg-primary:hover, button.bg-primary:focus, button.bg-primary:hover {
-  background-color: #138698 !important;
-}
-
-.border-primary {
-  border-color: #17a2b8 !important;
-}
-
-.btn-primary {
-  background-color: #17a2b8;
-  border-color: #17a2b8;
-}
-.btn-primary:hover {
-  background-color: #138698;
-  border-color: #138698;
-}
-
-.btn-primary:not(:disabled):not(.disabled).active, .btn-primary:not(:disabled):not(.disabled):active {
-  background-color: #138698;
-  border-color: #138698;
-}
-
-.btn-primary.focus, .btn-primary:focus {
-  background-color: #138698;
-  border-color: #138698;
-}
-
-.btn-outline-primary, .btn-outline-primary:not(:disabled):not(.disabled).active, .btn-outline-primary:not(:disabled):not(.disabled):active {
-  color: #17a2b8;
-  border-color: #17a2b8;
-}
-.btn-outline-primary:hover, .btn-outline-primary:not(:disabled):not(.disabled).active:hover, .btn-outline-primary:not(:disabled):not(.disabled):active:hover {
-  background-color: #17a2b8;
-  border-color: #17a2b8;
-  color: #fff;
-}
-
-.progress-bar,
-.nav-pills .nav-link.active, .nav-pills .show > .nav-link, .dropdown-item.active, .dropdown-item:active {
-  background-color: #17a2b8;
-}
-
-.page-item.active .page-link,
-.custom-radio .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label::before,
-.custom-checkbox .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label:before {
-  background-color: #17a2b8;
-  border-color: #17a2b8;
-}
-
-.list-group-item.active {
-  background-color: #17a2b8;
-  border-color: #17a2b8;
-}
-
-.page-link {
-  color: #17a2b8;
-}
-.page-link:hover {
-  color: #138698;
-}

docs/assets/css/color-green.css

@@ -1,159 +0,0 @@
-/*============================
-		COLOR Green
-==============================*/
-::selection {
-  background: #28a745;
-}
-
-a, a:focus {
-  color: #28a745;
-}
-
-a:hover, a:active {
-  color: #218a39;
-}
-
-.primary-menu ul.navbar-nav > li:hover > a:not(.btn), .primary-menu ul.navbar-nav > li > a.active:not(.btn) {
-  color: #28a745;
-}
-.primary-menu ul.navbar-nav > li.dropdown .dropdown-menu li:hover > a:not(.btn) {
-  color: #28a745;
-}
-.primary-menu.navbar-line-under-text ul.navbar-nav > li > a:not(.btn):after {
-  border-color: #28a745;
-}
-
-/*=== Side Navigation ===*/
-.idocs-navigation .nav .nav .nav-item .nav-link.active:after, .idocs-navigation.docs-navigation-dark .nav .nav .nav-item .nav-link.active:after {
-  border-color: #28a745;
-}
-
-/* Accordion & Toggle */
-.accordion .card-header a:hover.collapsed {
-  color: #28a745 !important;
-}
-.accordion:not(.accordion-alternate) .card-header a {
-  background-color: #28a745;
-  color: #fff;
-}
-
-/* Nav */
-.nav:not(.nav-pills) .nav-item .nav-link.active, .nav:not(.nav-pills) .nav-item .nav-link:hover {
-  color: #28a745;
-}
-
-.nav-tabs .nav-item .nav-link.active {
-  color: #0c2f55;
-}
-.nav-tabs .nav-item .nav-link.active:after {
-  background-color: #28a745;
-}
-.nav-tabs .nav-item .nav-link:not(.active):hover {
-  color: #28a745;
-}
-.nav-tabs.flex-column .nav-item .nav-link.active {
-  color: #28a745;
-}
-
-.nav-pills .nav-link:not(.active):hover {
-  color: #28a745;
-}
-
-#footer .nav .nav-item .nav-link:focus {
-  color: #28a745;
-}
-#footer .nav .nav-link:hover {
-  color: #28a745;
-}
-#footer .footer-copyright .nav .nav-link:hover {
-  color: #28a745;
-}
-
-/* Back to Top */
-#back-to-top:hover {
-  background-color: #28a745;
-}
-
-/* Extras */
-.bg-primary, .badge-primary {
-  background-color: #28a745 !important;
-}
-
-.text-primary, .btn-light, .btn-outline-light:hover, .btn-link, .btn-outline-light:not(:disabled):not(.disabled).active, .btn-outline-light:not(:disabled):not(.disabled):active {
-  color: #28a745 !important;
-}
-
-.btn-link:hover {
-  color: #218a39 !important;
-}
-
-.text-muted {
-  color: #8e9a9d !important;
-}
-
-.text-light {
-  color: #dee3e4 !important;
-}
-
-a.bg-primary:focus, a.bg-primary:hover, button.bg-primary:focus, button.bg-primary:hover {
-  background-color: #218a39 !important;
-}
-
-.border-primary {
-  border-color: #28a745 !important;
-}
-
-.btn-primary {
-  background-color: #28a745;
-  border-color: #28a745;
-}
-.btn-primary:hover {
-  background-color: #218a39;
-  border-color: #218a39;
-}
-
-.btn-primary:not(:disabled):not(.disabled).active, .btn-primary:not(:disabled):not(.disabled):active {
-  background-color: #218a39;
-  border-color: #218a39;
-}
-
-.btn-primary.focus, .btn-primary:focus {
-  background-color: #218a39;
-  border-color: #218a39;
-}
-
-.btn-outline-primary, .btn-outline-primary:not(:disabled):not(.disabled).active, .btn-outline-primary:not(:disabled):not(.disabled):active {
-  color: #28a745;
-  border-color: #28a745;
-}
-.btn-outline-primary:hover, .btn-outline-primary:not(:disabled):not(.disabled).active:hover, .btn-outline-primary:not(:disabled):not(.disabled):active:hover {
-  background-color: #28a745;
-  border-color: #28a745;
-  color: #fff;
-}
-
-.progress-bar,
-.nav-pills .nav-link.active, .nav-pills .show > .nav-link, .dropdown-item.active, .dropdown-item:active {
-  background-color: #28a745;
-}
-
-.page-item.active .page-link,
-.custom-radio .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label::before,
-.custom-checkbox .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label:before {
-  background-color: #28a745;
-  border-color: #28a745;
-}
-
-.list-group-item.active {
-  background-color: #28a745;
-  border-color: #28a745;
-}
-
-.page-link {
-  color: #28a745;
-}
-.page-link:hover {
-  color: #218a39;
-}

docs/assets/css/color-indigo.css

@@ -1,159 +0,0 @@
-/*============================
-		COLOR Indigo
-==============================*/
-::selection {
-  background: #6610f2;
-}
-
-a, a:focus {
-  color: #6610f2;
-}
-
-a:hover, a:active {
-  color: #570bd3;
-}
-
-.primary-menu ul.navbar-nav > li:hover > a:not(.btn), .primary-menu ul.navbar-nav > li > a.active:not(.btn) {
-  color: #6610f2;
-}
-.primary-menu ul.navbar-nav > li.dropdown .dropdown-menu li:hover > a:not(.btn) {
-  color: #6610f2;
-}
-.primary-menu.navbar-line-under-text ul.navbar-nav > li > a:not(.btn):after {
-  border-color: #6610f2;
-}
-
-/*=== Side Navigation ===*/
-.idocs-navigation .nav .nav .nav-item .nav-link.active:after, .idocs-navigation.docs-navigation-dark .nav .nav .nav-item .nav-link.active:after {
-  border-color: #6610f2;
-}
-
-/* Accordion & Toggle */
-.accordion .card-header a:hover.collapsed {
-  color: #6610f2 !important;
-}
-.accordion:not(.accordion-alternate) .card-header a {
-  background-color: #6610f2;
-  color: #fff;
-}
-
-/* Nav */
-.nav:not(.nav-pills) .nav-item .nav-link.active, .nav:not(.nav-pills) .nav-item .nav-link:hover {
-  color: #6610f2;
-}
-
-.nav-tabs .nav-item .nav-link.active {
-  color: #0c2f55;
-}
-.nav-tabs .nav-item .nav-link.active:after {
-  background-color: #6610f2;
-}
-.nav-tabs .nav-item .nav-link:not(.active):hover {
-  color: #6610f2;
-}
-.nav-tabs.flex-column .nav-item .nav-link.active {
-  color: #6610f2;
-}
-
-.nav-pills .nav-link:not(.active):hover {
-  color: #6610f2;
-}
-
-#footer .nav .nav-item .nav-link:focus {
-  color: #6610f2;
-}
-#footer .nav .nav-link:hover {
-  color: #6610f2;
-}
-#footer .footer-copyright .nav .nav-link:hover {
-  color: #6610f2;
-}
-
-/* Back to Top */
-#back-to-top:hover {
-  background-color: #6610f2;
-}
-
-/* Extras */
-.bg-primary, .badge-primary {
-  background-color: #6610f2 !important;
-}
-
-.text-primary, .btn-light, .btn-outline-light:hover, .btn-link, .btn-outline-light:not(:disabled):not(.disabled).active, .btn-outline-light:not(:disabled):not(.disabled):active {
-  color: #6610f2 !important;
-}
-
-.btn-link:hover {
-  color: #570bd3 !important;
-}
-
-.text-muted {
-  color: #8e9a9d !important;
-}
-
-.text-light {
-  color: #dee3e4 !important;
-}
-
-a.bg-primary:focus, a.bg-primary:hover, button.bg-primary:focus, button.bg-primary:hover {
-  background-color: #570bd3 !important;
-}
-
-.border-primary {
-  border-color: #6610f2 !important;
-}
-
-.btn-primary {
-  background-color: #6610f2;
-  border-color: #6610f2;
-}
-.btn-primary:hover {
-  background-color: #570bd3;
-  border-color: #570bd3;
-}
-
-.btn-primary:not(:disabled):not(.disabled).active, .btn-primary:not(:disabled):not(.disabled):active {
-  background-color: #570bd3;
-  border-color: #570bd3;
-}
-
-.btn-primary.focus, .btn-primary:focus {
-  background-color: #570bd3;
-  border-color: #570bd3;
-}
-
-.btn-outline-primary, .btn-outline-primary:not(:disabled):not(.disabled).active, .btn-outline-primary:not(:disabled):not(.disabled):active {
-  color: #6610f2;
-  border-color: #6610f2;
-}
-.btn-outline-primary:hover, .btn-outline-primary:not(:disabled):not(.disabled).active:hover, .btn-outline-primary:not(:disabled):not(.disabled):active:hover {
-  background-color: #6610f2;
-  border-color: #6610f2;
-  color: #fff;
-}
-
-.progress-bar,
-.nav-pills .nav-link.active, .nav-pills .show > .nav-link, .dropdown-item.active, .dropdown-item:active {
-  background-color: #6610f2;
-}
-
-.page-item.active .page-link,
-.custom-radio .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label::before,
-.custom-checkbox .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label:before {
-  background-color: #6610f2;
-  border-color: #6610f2;
-}
-
-.list-group-item.active {
-  background-color: #6610f2;
-  border-color: #6610f2;
-}
-
-.page-link {
-  color: #6610f2;
-}
-.page-link:hover {
-  color: #570bd3;
-}

docs/assets/css/color-orange.css

@@ -1,159 +0,0 @@
-/*============================
-		COLOR Orange
-==============================*/
-::selection {
-  background: #fd7e14;
-}
-
-a, a:focus {
-  color: #fd7e14;
-}
-
-a:hover, a:active {
-  color: #eb6c02;
-}
-
-.primary-menu ul.navbar-nav > li:hover > a:not(.btn), .primary-menu ul.navbar-nav > li > a.active:not(.btn) {
-  color: #fd7e14;
-}
-.primary-menu ul.navbar-nav > li.dropdown .dropdown-menu li:hover > a:not(.btn) {
-  color: #fd7e14;
-}
-.primary-menu.navbar-line-under-text ul.navbar-nav > li > a:not(.btn):after {
-  border-color: #fd7e14;
-}
-
-/*=== Side Navigation ===*/
-.idocs-navigation .nav .nav .nav-item .nav-link.active:after, .idocs-navigation.docs-navigation-dark .nav .nav .nav-item .nav-link.active:after {
-  border-color: #fd7e14;
-}
-
-/* Accordion & Toggle */
-.accordion .card-header a:hover.collapsed {
-  color: #fd7e14 !important;
-}
-.accordion:not(.accordion-alternate) .card-header a {
-  background-color: #fd7e14;
-  color: #fff;
-}
-
-/* Nav */
-.nav:not(.nav-pills) .nav-item .nav-link.active, .nav:not(.nav-pills) .nav-item .nav-link:hover {
-  color: #fd7e14;
-}
-
-.nav-tabs .nav-item .nav-link.active {
-  color: #0c2f55;
-}
-.nav-tabs .nav-item .nav-link.active:after {
-  background-color: #fd7e14;
-}
-.nav-tabs .nav-item .nav-link:not(.active):hover {
-  color: #fd7e14;
-}
-.nav-tabs.flex-column .nav-item .nav-link.active {
-  color: #fd7e14;
-}
-
-.nav-pills .nav-link:not(.active):hover {
-  color: #fd7e14;
-}
-
-#footer .nav .nav-item .nav-link:focus {
-  color: #fd7e14;
-}
-#footer .nav .nav-link:hover {
-  color: #fd7e14;
-}
-#footer .footer-copyright .nav .nav-link:hover {
-  color: #fd7e14;
-}
-
-/* Back to Top */
-#back-to-top:hover {
-  background-color: #fd7e14;
-}
-
-/* Extras */
-.bg-primary, .badge-primary {
-  background-color: #fd7e14 !important;
-}
-
-.text-primary, .btn-light, .btn-outline-light:hover, .btn-link, .btn-outline-light:not(:disabled):not(.disabled).active, .btn-outline-light:not(:disabled):not(.disabled):active {
-  color: #fd7e14 !important;
-}
-
-.btn-link:hover {
-  color: #eb6c02 !important;
-}
-
-.text-muted {
-  color: #8e9a9d !important;
-}
-
-.text-light {
-  color: #dee3e4 !important;
-}
-
-a.bg-primary:focus, a.bg-primary:hover, button.bg-primary:focus, button.bg-primary:hover {
-  background-color: #eb6c02 !important;
-}
-
-.border-primary {
-  border-color: #fd7e14 !important;
-}
-
-.btn-primary {
-  background-color: #fd7e14;
-  border-color: #fd7e14;
-}
-.btn-primary:hover {
-  background-color: #eb6c02;
-  border-color: #eb6c02;
-}
-
-.btn-primary:not(:disabled):not(.disabled).active, .btn-primary:not(:disabled):not(.disabled):active {
-  background-color: #eb6c02;
-  border-color: #eb6c02;
-}
-
-.btn-primary.focus, .btn-primary:focus {
-  background-color: #eb6c02;
-  border-color: #eb6c02;
-}
-
-.btn-outline-primary, .btn-outline-primary:not(:disabled):not(.disabled).active, .btn-outline-primary:not(:disabled):not(.disabled):active {
-  color: #fd7e14;
-  border-color: #fd7e14;
-}
-.btn-outline-primary:hover, .btn-outline-primary:not(:disabled):not(.disabled).active:hover, .btn-outline-primary:not(:disabled):not(.disabled):active:hover {
-  background-color: #fd7e14;
-  border-color: #fd7e14;
-  color: #fff;
-}
-
-.progress-bar,
-.nav-pills .nav-link.active, .nav-pills .show > .nav-link, .dropdown-item.active, .dropdown-item:active {
-  background-color: #fd7e14;
-}
-
-.page-item.active .page-link,
-.custom-radio .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label::before,
-.custom-checkbox .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label:before {
-  background-color: #fd7e14;
-  border-color: #fd7e14;
-}
-
-.list-group-item.active {
-  background-color: #fd7e14;
-  border-color: #fd7e14;
-}
-
-.page-link {
-  color: #fd7e14;
-}
-.page-link:hover {
-  color: #eb6c02;
-}

docs/assets/css/color-purple.css

@@ -1,159 +0,0 @@
-/*============================
-		COLOR Purple
-==============================*/
-::selection {
-  background: #6f42c1;
-}
-
-a, a:focus {
-  color: #6f42c1;
-}
-
-a:hover, a:active {
-  color: #5f37a8;
-}
-
-.primary-menu ul.navbar-nav > li:hover > a:not(.btn), .primary-menu ul.navbar-nav > li > a.active:not(.btn) {
-  color: #6f42c1;
-}
-.primary-menu ul.navbar-nav > li.dropdown .dropdown-menu li:hover > a:not(.btn) {
-  color: #6f42c1;
-}
-.primary-menu.navbar-line-under-text ul.navbar-nav > li > a:not(.btn):after {
-  border-color: #6f42c1;
-}
-
-/*=== Side Navigation ===*/
-.idocs-navigation .nav .nav .nav-item .nav-link.active:after, .idocs-navigation.docs-navigation-dark .nav .nav .nav-item .nav-link.active:after {
-  border-color: #6f42c1;
-}
-
-/* Accordion & Toggle */
-.accordion .card-header a:hover.collapsed {
-  color: #6f42c1 !important;
-}
-.accordion:not(.accordion-alternate) .card-header a {
-  background-color: #6f42c1;
-  color: #fff;
-}
-
-/* Nav */
-.nav:not(.nav-pills) .nav-item .nav-link.active, .nav:not(.nav-pills) .nav-item .nav-link:hover {
-  color: #6f42c1;
-}
-
-.nav-tabs .nav-item .nav-link.active {
-  color: #0c2f55;
-}
-.nav-tabs .nav-item .nav-link.active:after {
-  background-color: #6f42c1;
-}
-.nav-tabs .nav-item .nav-link:not(.active):hover {
-  color: #6f42c1;
-}
-.nav-tabs.flex-column .nav-item .nav-link.active {
-  color: #6f42c1;
-}
-
-.nav-pills .nav-link:not(.active):hover {
-  color: #6f42c1;
-}
-
-#footer .nav .nav-item .nav-link:focus {
-  color: #6f42c1;
-}
-#footer .nav .nav-link:hover {
-  color: #6f42c1;
-}
-#footer .footer-copyright .nav .nav-link:hover {
-  color: #6f42c1;
-}
-
-/* Back to Top */
-#back-to-top:hover {
-  background-color: #6f42c1;
-}
-
-/* Extras */
-.bg-primary, .badge-primary {
-  background-color: #6f42c1 !important;
-}
-
-.text-primary, .btn-light, .btn-outline-light:hover, .btn-link, .btn-outline-light:not(:disabled):not(.disabled).active, .btn-outline-light:not(:disabled):not(.disabled):active {
-  color: #6f42c1 !important;
-}
-
-.btn-link:hover {
-  color: #5f37a8 !important;
-}
-
-.text-muted {
-  color: #8e9a9d !important;
-}
-
-.text-light {
-  color: #dee3e4 !important;
-}
-
-a.bg-primary:focus, a.bg-primary:hover, button.bg-primary:focus, button.bg-primary:hover {
-  background-color: #5f37a8 !important;
-}
-
-.border-primary {
-  border-color: #6f42c1 !important;
-}
-
-.btn-primary {
-  background-color: #6f42c1;
-  border-color: #6f42c1;
-}
-.btn-primary:hover {
-  background-color: #5f37a8;
-  border-color: #5f37a8;
-}
-
-.btn-primary:not(:disabled):not(.disabled).active, .btn-primary:not(:disabled):not(.disabled):active {
-  background-color: #5f37a8;
-  border-color: #5f37a8;
-}
-
-.btn-primary.focus, .btn-primary:focus {
-  background-color: #5f37a8;
-  border-color: #5f37a8;
-}
-
-.btn-outline-primary, .btn-outline-primary:not(:disabled):not(.disabled).active, .btn-outline-primary:not(:disabled):not(.disabled):active {
-  color: #6f42c1;
-  border-color: #6f42c1;
-}
-.btn-outline-primary:hover, .btn-outline-primary:not(:disabled):not(.disabled).active:hover, .btn-outline-primary:not(:disabled):not(.disabled):active:hover {
-  background-color: #6f42c1;
-  border-color: #6f42c1;
-  color: #fff;
-}
-
-.progress-bar,
-.nav-pills .nav-link.active, .nav-pills .show > .nav-link, .dropdown-item.active, .dropdown-item:active {
-  background-color: #6f42c1;
-}
-
-.page-item.active .page-link,
-.custom-radio .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label::before,
-.custom-checkbox .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label:before {
-  background-color: #6f42c1;
-  border-color: #6f42c1;
-}
-
-.list-group-item.active {
-  background-color: #6f42c1;
-  border-color: #6f42c1;
-}
-
-.page-link {
-  color: #6f42c1;
-}
-.page-link:hover {
-  color: #5f37a8;
-}

docs/assets/css/color-red.css

@@ -1,159 +0,0 @@
-/*============================
-		COLOR Red
-==============================*/
-::selection {
-  background: #dc3545;
-}
-
-a, a:focus {
-  color: #dc3545;
-}
-
-a:hover, a:active {
-  color: #ca2333;
-}
-
-.primary-menu ul.navbar-nav > li:hover > a:not(.btn), .primary-menu ul.navbar-nav > li > a.active:not(.btn) {
-  color: #dc3545;
-}
-.primary-menu ul.navbar-nav > li.dropdown .dropdown-menu li:hover > a:not(.btn) {
-  color: #dc3545;
-}
-.primary-menu.navbar-line-under-text ul.navbar-nav > li > a:not(.btn):after {
-  border-color: #dc3545;
-}
-
-/*=== Side Navigation ===*/
-.idocs-navigation .nav .nav .nav-item .nav-link.active:after, .idocs-navigation.docs-navigation-dark .nav .nav .nav-item .nav-link.active:after {
-  border-color: #dc3545;
-}
-
-/* Accordion & Toggle */
-.accordion .card-header a:hover.collapsed {
-  color: #dc3545 !important;
-}
-.accordion:not(.accordion-alternate) .card-header a {
-  background-color: #dc3545;
-  color: #fff;
-}
-
-/* Nav */
-.nav:not(.nav-pills) .nav-item .nav-link.active, .nav:not(.nav-pills) .nav-item .nav-link:hover {
-  color: #dc3545;
-}
-
-.nav-tabs .nav-item .nav-link.active {
-  color: #0c2f55;
-}
-.nav-tabs .nav-item .nav-link.active:after {
-  background-color: #dc3545;
-}
-.nav-tabs .nav-item .nav-link:not(.active):hover {
-  color: #dc3545;
-}
-.nav-tabs.flex-column .nav-item .nav-link.active {
-  color: #dc3545;
-}
-
-.nav-pills .nav-link:not(.active):hover {
-  color: #dc3545;
-}
-
-#footer .nav .nav-item .nav-link:focus {
-  color: #dc3545;
-}
-#footer .nav .nav-link:hover {
-  color: #dc3545;
-}
-#footer .footer-copyright .nav .nav-link:hover {
-  color: #dc3545;
-}
-
-/* Back to Top */
-#back-to-top:hover {
-  background-color: #dc3545;
-}
-
-/* Extras */
-.bg-primary, .badge-primary {
-  background-color: #dc3545 !important;
-}
-
-.text-primary, .btn-light, .btn-outline-light:hover, .btn-link, .btn-outline-light:not(:disabled):not(.disabled).active, .btn-outline-light:not(:disabled):not(.disabled):active {
-  color: #dc3545 !important;
-}
-
-.btn-link:hover {
-  color: #ca2333 !important;
-}
-
-.text-muted {
-  color: #8e9a9d !important;
-}
-
-.text-light {
-  color: #dee3e4 !important;
-}
-
-a.bg-primary:focus, a.bg-primary:hover, button.bg-primary:focus, button.bg-primary:hover {
-  background-color: #ca2333 !important;
-}
-
-.border-primary {
-  border-color: #dc3545 !important;
-}
-
-.btn-primary {
-  background-color: #dc3545;
-  border-color: #dc3545;
-}
-.btn-primary:hover {
-  background-color: #ca2333;
-  border-color: #ca2333;
-}
-
-.btn-primary:not(:disabled):not(.disabled).active, .btn-primary:not(:disabled):not(.disabled):active {
-  background-color: #ca2333;
-  border-color: #ca2333;
-}
-
-.btn-primary.focus, .btn-primary:focus {
-  background-color: #ca2333;
-  border-color: #ca2333;
-}
-
-.btn-outline-primary, .btn-outline-primary:not(:disabled):not(.disabled).active, .btn-outline-primary:not(:disabled):not(.disabled):active {
-  color: #dc3545;
-  border-color: #dc3545;
-}
-.btn-outline-primary:hover, .btn-outline-primary:not(:disabled):not(.disabled).active:hover, .btn-outline-primary:not(:disabled):not(.disabled):active:hover {
-  background-color: #dc3545;
-  border-color: #dc3545;
-  color: #fff;
-}
-
-.progress-bar,
-.nav-pills .nav-link.active, .nav-pills .show > .nav-link, .dropdown-item.active, .dropdown-item:active {
-  background-color: #dc3545;
-}
-
-.page-item.active .page-link,
-.custom-radio .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label::before,
-.custom-checkbox .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label:before {
-  background-color: #dc3545;
-  border-color: #dc3545;
-}
-
-.list-group-item.active {
-  background-color: #dc3545;
-  border-color: #dc3545;
-}
-
-.page-link {
-  color: #dc3545;
-}
-.page-link:hover {
-  color: #ca2333;
-}

docs/assets/css/color-teal.css

@@ -1,159 +0,0 @@
-/*============================
-		COLOR Teal
-==============================*/
-::selection {
-  background: #20c997;
-}
-
-a, a:focus {
-  color: #20c997;
-}
-
-a:hover, a:active {
-  color: #1baa80;
-}
-
-.primary-menu ul.navbar-nav > li:hover > a:not(.btn), .primary-menu ul.navbar-nav > li > a.active:not(.btn) {
-  color: #20c997;
-}
-.primary-menu ul.navbar-nav > li.dropdown .dropdown-menu li:hover > a:not(.btn) {
-  color: #20c997;
-}
-.primary-menu.navbar-line-under-text ul.navbar-nav > li > a:not(.btn):after {
-  border-color: #20c997;
-}
-
-/*=== Side Navigation ===*/
-.idocs-navigation .nav .nav .nav-item .nav-link.active:after, .idocs-navigation.docs-navigation-dark .nav .nav .nav-item .nav-link.active:after {
-  border-color: #20c997;
-}
-
-/* Accordion & Toggle */
-.accordion .card-header a:hover.collapsed {
-  color: #20c997 !important;
-}
-.accordion:not(.accordion-alternate) .card-header a {
-  background-color: #20c997;
-  color: #fff;
-}
-
-/* Nav */
-.nav:not(.nav-pills) .nav-item .nav-link.active, .nav:not(.nav-pills) .nav-item .nav-link:hover {
-  color: #20c997;
-}
-
-.nav-tabs .nav-item .nav-link.active {
-  color: #0c2f55;
-}
-.nav-tabs .nav-item .nav-link.active:after {
-  background-color: #20c997;
-}
-.nav-tabs .nav-item .nav-link:not(.active):hover {
-  color: #20c997;
-}
-.nav-tabs.flex-column .nav-item .nav-link.active {
-  color: #20c997;
-}
-
-.nav-pills .nav-link:not(.active):hover {
-  color: #20c997;
-}
-
-#footer .nav .nav-item .nav-link:focus {
-  color: #20c997;
-}
-#footer .nav .nav-link:hover {
-  color: #20c997;
-}
-#footer .footer-copyright .nav .nav-link:hover {
-  color: #20c997;
-}
-
-/* Back to Top */
-#back-to-top:hover {
-  background-color: #20c997;
-}
-
-/* Extras */
-.bg-primary, .badge-primary {
-  background-color: #20c997 !important;
-}
-
-.text-primary, .btn-light, .btn-outline-light:hover, .btn-link, .btn-outline-light:not(:disabled):not(.disabled).active, .btn-outline-light:not(:disabled):not(.disabled):active {
-  color: #20c997 !important;
-}
-
-.btn-link:hover {
-  color: #1baa80 !important;
-}
-
-.text-muted {
-  color: #8e9a9d !important;
-}
-
-.text-light {
-  color: #dee3e4 !important;
-}
-
-a.bg-primary:focus, a.bg-primary:hover, button.bg-primary:focus, button.bg-primary:hover {
-  background-color: #1baa80 !important;
-}
-
-.border-primary {
-  border-color: #20c997 !important;
-}
-
-.btn-primary {
-  background-color: #20c997;
-  border-color: #20c997;
-}
-.btn-primary:hover {
-  background-color: #1baa80;
-  border-color: #1baa80;
-}
-
-.btn-primary:not(:disabled):not(.disabled).active, .btn-primary:not(:disabled):not(.disabled):active {
-  background-color: #1baa80;
-  border-color: #1baa80;
-}
-
-.btn-primary.focus, .btn-primary:focus {
-  background-color: #1baa80;
-  border-color: #1baa80;
-}
-
-.btn-outline-primary, .btn-outline-primary:not(:disabled):not(.disabled).active, .btn-outline-primary:not(:disabled):not(.disabled):active {
-  color: #20c997;
-  border-color: #20c997;
-}
-.btn-outline-primary:hover, .btn-outline-primary:not(:disabled):not(.disabled).active:hover, .btn-outline-primary:not(:disabled):not(.disabled):active:hover {
-  background-color: #20c997;
-  border-color: #20c997;
-  color: #fff;
-}
-
-.progress-bar,
-.nav-pills .nav-link.active, .nav-pills .show > .nav-link, .dropdown-item.active, .dropdown-item:active {
-  background-color: #20c997;
-}
-
-.page-item.active .page-link,
-.custom-radio .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label::before,
-.custom-checkbox .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label:before {
-  background-color: #20c997;
-  border-color: #20c997;
-}
-
-.list-group-item.active {
-  background-color: #20c997;
-  border-color: #20c997;
-}
-
-.page-link {
-  color: #20c997;
-}
-.page-link:hover {
-  color: #1baa80;
-}

docs/assets/css/color-yellow.css

@@ -1,159 +0,0 @@
-/*============================
-		COLOR Yellow
-==============================*/
-::selection {
-  background: #ffc107;
-}
-
-a, a:focus {
-  color: #ffc107;
-}
-
-a:hover, a:active {
-  color: #f7b900;
-}
-
-.primary-menu ul.navbar-nav > li:hover > a:not(.btn), .primary-menu ul.navbar-nav > li > a.active:not(.btn) {
-  color: #ffc107;
-}
-.primary-menu ul.navbar-nav > li.dropdown .dropdown-menu li:hover > a:not(.btn) {
-  color: #ffc107;
-}
-.primary-menu.navbar-line-under-text ul.navbar-nav > li > a:not(.btn):after {
-  border-color: #ffc107;
-}
-
-/*=== Side Navigation ===*/
-.idocs-navigation .nav .nav .nav-item .nav-link.active:after, .idocs-navigation.docs-navigation-dark .nav .nav .nav-item .nav-link.active:after {
-  border-color: #ffc107;
-}
-
-/* Accordion & Toggle */
-.accordion .card-header a:hover.collapsed {
-  color: #ffc107 !important;
-}
-.accordion:not(.accordion-alternate) .card-header a {
-  background-color: #ffc107;
-  color: #fff;
-}
-
-/* Nav */
-.nav:not(.nav-pills) .nav-item .nav-link.active, .nav:not(.nav-pills) .nav-item .nav-link:hover {
-  color: #ffc107;
-}
-
-.nav-tabs .nav-item .nav-link.active {
-  color: #0c2f55;
-}
-.nav-tabs .nav-item .nav-link.active:after {
-  background-color: #ffc107;
-}
-.nav-tabs .nav-item .nav-link:not(.active):hover {
-  color: #ffc107;
-}
-.nav-tabs.flex-column .nav-item .nav-link.active {
-  color: #ffc107;
-}
-
-.nav-pills .nav-link:not(.active):hover {
-  color: #ffc107;
-}
-
-#footer .nav .nav-item .nav-link:focus {
-  color: #ffc107;
-}
-#footer .nav .nav-link:hover {
-  color: #ffc107;
-}
-#footer .footer-copyright .nav .nav-link:hover {
-  color: #ffc107;
-}
-
-/* Back to Top */
-#back-to-top:hover {
-  background-color: #ffc107;
-}
-
-/* Extras */
-.bg-primary, .badge-primary {
-  background-color: #ffc107 !important;
-}
-
-.text-primary, .btn-light, .btn-outline-light:hover, .btn-link, .btn-outline-light:not(:disabled):not(.disabled).active, .btn-outline-light:not(:disabled):not(.disabled):active {
-  color: #ffc107 !important;
-}
-
-.btn-link:hover {
-  color: #f7b900 !important;
-}
-
-.text-muted {
-  color: #8e9a9d !important;
-}
-
-.text-light {
-  color: #dee3e4 !important;
-}
-
-a.bg-primary:focus, a.bg-primary:hover, button.bg-primary:focus, button.bg-primary:hover {
-  background-color: #f7b900 !important;
-}
-
-.border-primary {
-  border-color: #ffc107 !important;
-}
-
-.btn-primary {
-  background-color: #ffc107;
-  border-color: #ffc107;
-}
-.btn-primary:hover {
-  background-color: #f7b900;
-  border-color: #f7b900;
-}
-
-.btn-primary:not(:disabled):not(.disabled).active, .btn-primary:not(:disabled):not(.disabled):active {
-  background-color: #f7b900;
-  border-color: #f7b900;
-}
-
-.btn-primary.focus, .btn-primary:focus {
-  background-color: #f7b900;
-  border-color: #f7b900;
-}
-
-.btn-outline-primary, .btn-outline-primary:not(:disabled):not(.disabled).active, .btn-outline-primary:not(:disabled):not(.disabled):active {
-  color: #ffc107;
-  border-color: #ffc107;
-}
-.btn-outline-primary:hover, .btn-outline-primary:not(:disabled):not(.disabled).active:hover, .btn-outline-primary:not(:disabled):not(.disabled):active:hover {
-  background-color: #ffc107;
-  border-color: #ffc107;
-  color: #fff;
-}
-
-.progress-bar,
-.nav-pills .nav-link.active, .nav-pills .show > .nav-link, .dropdown-item.active, .dropdown-item:active {
-  background-color: #ffc107;
-}
-
-.page-item.active .page-link,
-.custom-radio .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label::before,
-.custom-checkbox .custom-control-input:checked ~ .custom-control-label:before,
-.custom-control-input:checked ~ .custom-control-label:before {
-  background-color: #ffc107;
-  border-color: #ffc107;
-}
-
-.list-group-item.active {
-  background-color: #ffc107;
-  border-color: #ffc107;
-}
-
-.page-link {
-  color: #ffc107;
-}
-.page-link:hover {
-  color: #f7b900;
-}

docs/assets/js/theme.js

@@ -1,162 +0,0 @@
-/*
-================================================================
-* Template:  	 iDocs - One Page Documentation HTML Template
-* Written by: 	 Harnish Design - (http://www.harnishdesign.net)
-* Description:   Main Custom Script File
-================================================================
-*/
-
-
-(function ($) {
-	"use strict";
-
-// Preloader
-$(window).on('load', function () {
-	$('.lds-ellipsis').fadeOut(); // will first fade out the loading animation
-	$('.preloader').delay(333).fadeOut('slow'); // will fade out the white DIV that covers the website.
-	$('body').delay(333);
-});
-
-/*-------------------------------
-    Primary Menu
---------------------------------- */
-
-// Dropdown show on hover
-$('.primary-menu ul.navbar-nav li.dropdown, .login-signup ul.navbar-nav li.dropdown').on("mouseover", function() {
-	if ($(window).width() > 991) {
-		$(this).find('> .dropdown-menu').stop().slideDown('fast');
-		$(this).bind('mouseleave', function() {
-		$(this).find('> .dropdown-menu').stop().css('display', 'none'); 
-		});
-	}
-});
-
-// When dropdown going off to the out of the screen.
-$('.primary-menu ul.navbar-nav .dropdown-menu').each(function() {
-		var menu = $('#header .container-fluid').offset();
-		var dropdown = $(this).parent().offset();
-
-		var i = (dropdown.left + $(this).outerWidth()) - (menu.left + $('#header .container-fluid').outerWidth());
-
-		if (i > 0) {
-			$(this).css('margin-left', '-' + (i + 5) + 'px');
-		}
-	});
-$(function () {
-    $(".dropdown li").on('mouseenter mouseleave', function (e) {
-		if ($(window).width() > 991) {
-            var elm = $('.dropdown-menu', this);
-            var off = elm.offset();
-            var l = off.left;
-            var w = elm.width();
-            var docW = $(window).width();
-            var isEntirelyVisible = (l + w + 30 <= docW);
-            if (!isEntirelyVisible) {
-                $(elm).addClass('dropdown-menu-right');
-            } else {
-                $(elm).removeClass('dropdown-menu-right');
-            }
-			}
-    });
-});
-
-// DropDown Arrow
-$('.primary-menu ul.navbar-nav').find('a.dropdown-toggle').append($('<i />').addClass('arrow'));
-
-
-// Mobile Collapse Nav
-$('.primary-menu .navbar-nav .dropdown-toggle[href="#"], .primary-menu .dropdown-toggle[href!="#"] .arrow').on('click', function(e) {
-	if ($(window).width() < 991) {
-        e.preventDefault();
-        var $parentli = $(this).closest('li');
-        $parentli.siblings('li').find('.dropdown-menu:visible').slideUp();
-        $parentli.find('> .dropdown-menu').stop().slideToggle();
-        $parentli.siblings('li').find('a .arrow.show').toggleClass('show');
-		$parentli.find('> a .arrow').toggleClass('show');
-	}
-});
-
-
-// Mobile Menu
-$('.navbar-toggler').on('click', function() {
-	$(this).toggleClass('show');
-});
-
-
-/*------------------------
-   Side Navigation
--------------------------- */
-
-$('#sidebarCollapse').on('click', function () {
-	$('#sidebarCollapse span:nth-child(3)').toggleClass('w-50');
-	$('.idocs-navigation').toggleClass('active');
-});
-
-
-/*------------------------
-   Sections Scroll
--------------------------- */
-
-$('.smooth-scroll,.idocs-navigation a').on('click', function() {
-	event.preventDefault();
-    var sectionTo = $(this).attr('href');
-	$('html, body').stop().animate({
-      scrollTop: $(sectionTo).offset().top - 120}, 1000, 'easeInOutExpo');
-});
-
-/*-----------------------------
-    Magnific Popup
-------------------------------- */
-
-// Image on Modal
-$('.popup-img').each(function() {
-$(this).magnificPopup({
-	type: "image",
-	tLoading: '<div class="preloader"><div class="lds-ellipsis"><div></div><div></div><div></div><div></div></div></div>',
-    closeOnContentClick: !0,
-    mainClass: "mfp-fade",
-	
-});
-});
-
-// YouTube/Viemo Video & Gmaps
-$('.popup-youtube, .popup-vimeo, .popup-gmaps').each(function() {
-$(this).magnificPopup({
-        type: 'iframe',
-		mainClass: 'mfp-fade',
-});
-});
-
-
-/*------------------------
-   Highlight Js
--------------------------- */
-
-hljs.initHighlightingOnLoad();
-
-
-/*------------------------
-   tooltips
--------------------------- */
-$('[data-toggle=\'tooltip\']').tooltip({container: 'body'});
-
-
-/*------------------------
-   Scroll to top
--------------------------- */
-$(function () {
-		$(window).on('scroll', function(){
-			if ($(this).scrollTop() > 400) {
-				$('#back-to-top').fadeIn();
-			} else {
-				$('#back-to-top').fadeOut();
-			}
-		});
-		});
-$('#back-to-top').on("click", function() {
-	$('html, body').animate({scrollTop:0}, 'slow');
-	return false;
-});
-
-
-})(jQuery)

docs/assets/sass/_elements.scss

@@ -1,537 +0,0 @@
-/* =================================== */
-/*  5. Elements
-/* =================================== */
-
-/*=== 5.1 List Style ===*/
-
-.list-style-1 > li {
-  position: relative;
-  list-style-type: none;
-  line-height: 24px;
-  &:after {
-    content: " ";
-    position: absolute;
-    top: 12px;
-    left: -15px;
-    border-color: #000;
-    border-top: 1px solid;
-    border-right: 1px solid;
-    width: 6px;
-    height: 6px;
-    -webkit-transform: translate(-50%, -50%) rotate(45deg);
-    transform: translate(-50%, -50%) rotate(45deg);
-  }
-}
-
-.list-style-2{padding:0;}
-
-.list-style-2 > li {
-  list-style-type: none;
-  border-bottom: 1px solid #eaeaea;
-  padding-top: 12px;
-  padding-bottom: 12px;
-}
-.list-style-2.list-style-light > li {
-  border-bottom: 1px solid rgba(250,250,250,0.12);
-}
-
-/*=== 5.2 Changelog ===*/
-
-.changelog {
-  list-style: none;
-  padding: 0;
-  .badge {
-    width: 90px;
-    margin-right: 10px;
-    border-radius: .20rem;
-    text-transform: uppercase;
-  }
-  li {
-    line-height: 1.8;
-  }
-}
-
-
-/*=== 5.3 Accordion & Toggle ===*/
-.accordion {
-  .card {
-    border: none;
-    margin-bottom: 16px;
-    margin-bottom: 1rem;
-    background-color: transparent;
-  }
-  .card-header {
-    padding: 0;
-    border: none;
-    background: none;
-    a {
-      font-size: 16px;
-	  font-weight:normal;
-      padding: 1rem 1.25rem 1rem 2.25rem;
-      display: block;
-      border-radius: 4px;
-      position: relative;
-	 &:hover{
-		text-decoration:none;
-	}
-	 &:hover.collapsed {
-		color: $primary-color!important;
-	}
-    }
-  }
-  &:not(.accordion-alternate) .card-header a {
-    background-color: $primary-color;
-    color: #fff;
-    &.collapsed {
-      background-color: #f1f2f4;
-      color: #4c4d4d;
-    }
-	
-  }
-  .card-header a {
-    &:before {
-      position: absolute;
-      content: " ";
-      left: 20px;
-      top: calc(50% + 2px);
-      width: 9px;
-      height: 9px;
-      border-color: #CCC;
-      border-top: 2px solid;
-      border-right: 2px solid;
-      -webkit-transform: translate(-50%, -50%) rotate(-45deg);
-      transform: translate(-50%, -50%) rotate(-45deg);
-	  @include transition(all 0.2s ease);
-	  -webkit-backface-visibility: hidden;
-      backface-visibility: hidden;
-    }
-    &.collapsed:before {
-      top: calc(50% - 2px);
-      -webkit-transform: translate(-50%, -50%) rotate(135deg);
-      transform: translate(-50%, -50%) rotate(135deg);
-    }
-  }
-  .card-body {
-    line-height: 26px;
-  }
-  &.arrow-right .card-header a{
-		padding-left:1.25rem;
-    &:before {
-		right: 15px;
-		left: auto;
-	}
-  }
-  &.accordion-alternate {
-    .card {
-      margin: 0;
-    }
-    .card-header a {
-      padding-left: 1.40rem;
-      border-top: 1px solid #e4e9ec;
-      border-radius: 0px;
-    }
-    .card:first-of-type .card-header a {
-      border-top: 0px;
-    }
-    .card-header a {
-      &:before {
-        left: 6px;
-      }
-      &.collapsed {
-        color: #4c4d4d;
-      }
-    }
-    .card-body {
-      padding: 0rem 0 1rem 1.25rem;
-    }
-	&.arrow-right .card-header a{
-		padding-left:0;
-    &:before {
-		right: 0px;
-		left: auto;
-	}
-  }
-
-  }
-  &.toggle .card-header a {
-    &:before {
-      content: "-";
-      border: none;
-      font-size: 20px;
-      height: auto;
-      top: calc(50% + 2px);
-      width: auto;
-	  -webkit-transform: translate(-50%, -50%) rotate(180deg);
-      transform: translate(-50%, -50%) rotate(180deg);
-    }
-    &.collapsed:before {
-      content: "+";
-	  top: calc(50% - 1px);
-	  -webkit-transform: translate(-50%, -50%) rotate(0deg);
-      transform: translate(-50%, -50%) rotate(0deg);
-    }
-  }
-  &.accordion-alternate.style-2 {
-    .card-header a {
-      &:before {
-        right: 2px;
-        left: auto;
-		-webkit-transform: translate(-50%, -50%) rotate(135deg);
-        transform: translate(-50%, -50%) rotate(135deg);
-        top: 50%;
-      }
-      &.collapsed:before {
-	  	-webkit-transform: translate(-50%, -50%) rotate(45deg);
-        transform: translate(-50%, -50%) rotate(45deg);
-      }
-      padding-left: 0px;
-    }
-    .card-body {
-      padding-left: 0px;
-    }
-  }
-  &.accordion-alternate.popularRoutes {
-	.card-header {
-	  .nav {
-		margin-top: 3px;
-		a {
-		  font-size: 14px;
-		}
-	  }
-	  a {
-		padding: 0px 8px 0px 0px;
-		border: none;
-		font-size: inherit;
-		&:before {
-		  content: none;
-		}
-	  }
-	  h5 {
-		cursor: pointer;
-		&:before {
-		  position: absolute;
-		  content: " ";
-		  right: 0px;
-		  top: 24px;
-		  width: 10px;
-		  height: 10px;
-		  opacity: 0.6;
-		  border-top: 2px solid;
-		  border-right: 2px solid;
-		  -webkit-transform: translate(-50%, -50%) rotate(-45deg);
-		  transform: translate(-50%, -50%) rotate(-45deg);
-		  -webkit-transition: all 0.2s ease;
-		  transition: all 0.2s ease;
-		  -webkit-backface-visibility: hidden;
-		  backface-visibility: hidden;
-		}
-		&.collapsed:before {
-		  top: 24px;
-		  -webkit-transform: translate(-50%, -50%) rotate(135deg);
-		  transform: translate(-50%, -50%) rotate(135deg);
-		}
-	  }
-	}
-	.card-body {
-	  padding: 0;
-	}
-	.card {
-	  border-bottom: 2px solid #e4e9ec;
-	  padding: 15px 0px;
-	}
-	.routes-list {
-	  margin: 1rem 0px 0px 0px;
-	  padding: 0px;
-	  list-style: none;
-	  a {
-		color: inherit;
-		display: -ms-flexbox !important;
-		display: flex !important;
-		-ms-flex-align: center !important;
-		align-items: center !important;
-		&:hover {
-		  color: #0071cc;
-		  text-decoration: underline;
-		}
-	  }
-	}
-  }
-}
-
-/* 5.4 Nav */
-
-.nav .nav-item .nav-link{color: #222222;}
-.nav.nav-light .nav-item .nav-link{color: #ddd;}
-.nav:not(.nav-pills) .nav-item .nav-link.active, .nav:not(.nav-pills) .nav-item .nav-link:hover{color: $primary-color;}
-
-
-.nav-pills .nav-link:not(.active):hover{color: $primary-color;}
-.nav-pills .nav-link.active,.nav-pills.nav-light .nav-link.active, .nav-pills .show > .nav-link{color:#fff;}
-
-.nav.nav-separator .nav-item .nav-link{position:relative;}
-.nav.nav-separator .nav-item + .nav-item .nav-link:after{
-		height: 14px;
-        width: 1px;
-        content: ' ';
-        background-color: rgba(0,0,0,0.2);
-        display: block;
-        position: absolute;
-        top: 50%;
-        left: 0;
-		@include translateY(-7px);
-}
-.nav.nav-separator.nav-separator-light .nav-item + .nav-item .nav-link:after{
-background-color: rgba(250,250,250,0.2);
-}
-
-.nav.nav-sm .nav-item .nav-link{font-size:14px;}
-
-
-/*=== 5.5 Tabs ===*/
-
-.nav-tabs {
-  border-bottom: 1px solid #d7dee3;
-  .nav-item .nav-link {
-	border:0;
-    background: transparent;
-    
-    position: relative;
-    border-radius: 0;
-	padding:0.6rem 1rem;
-    color: #7b8084;
-	white-space: nowrap !important;
-    &.active {
-      &:after {
-        height: 2px;
-        width: 100%;
-        content: ' ';
-        background-color: $primary-color;
-        display: block;
-        position: absolute;
-        bottom: -3px;
-        left: 0;
-		@include translateY(-3px);
-      }
-      color: #0c2f55;
-    }
-	&:not(.active):hover {
-      color: $primary-color;
-    }
-  }
-  &.flex-column {
-    border-right: 1px solid #d7dee3;
-    border-bottom: 0px;
-    padding: 1.5rem 0;
-    .nav-item {
-      .nav-link {
-        border: 1px solid #d7dee3;
-        border-right: 0px;
-        background-color: #f6f7f8;
-        font-size: 14px;
-        padding: 0.75rem 1rem;
-        color: #535b61;
-      }
-      &:first-of-type .nav-link {
-        border-top-left-radius: 4px;
-      }
-      &:last-of-type .nav-link {
-        border-bottom-left-radius: 4px;
-      }
-      .nav-link.active {
-        &:after {
-          height: 100%;
-          width: 2px;
-          background: #fff;
-          right: -1px;
-          left: auto;
-        }
-        background-color: transparent;
-        color: $primary-color;
-      }
-    }
-  }
-}
-
-.nav-tabs:not(.flex-column) {
-  .nav-item {
-    margin-bottom: 0px;
-  }
-  flex-wrap: nowrap;
-  overflow: hidden;
-  overflow-x: auto;
-  -ms-overflow-style: -ms-autohiding-scrollbar;
-  -webkit-overflow-scrolling: touch;
-}
-
-
-
-@include media-breakpoint-down(xs) {
-  .nav-tabs .nav-item .nav-link {
-	padding-left: 0px;
-	padding-right: 0px;
-	margin-right: 10px;
-	font-size: 0.875rem;
-  }
-}
-
-
-/*=== 5.6 Popup Img ===*/
-.popup-img img{@include transition(all 0.2s ease-in-out);}
-.popup-img:hover img{
-	opacity:0.8;
-	cursor: -webkit-zoom-in;
-    cursor: -moz-zoom-in;
-    cursor: zoom-in;
-}
-
-
-/*=== 5.7 Featured Box ===*/
-.featured-box {
-  box-sizing: border-box;
-  position: relative;
-  h3, h4 {
-  	font-size: 1.25rem;
-	font-size: 20px;
-    margin-bottom: 10px;
-    font-weight: 500;
-  }
-  &:not(.style-5) .featured-box-icon {
-    display: inline-block;
-    font-size: 48px;
-	min-width: 55px;
-    min-height: 55px;
-    padding: 0;
-    margin-top: 0;
-    margin-bottom: 0.8rem;
-    color: #4c4d4d;
-    border-radius: 0;
-  }
-  &.style-1, &.style-2, &.style-3 {
-    padding-left: 50px;
-    padding-top: 8px;
-  }
-  &.style-1 .featured-box-icon, &.style-2 .featured-box-icon, &.style-3 .featured-box-icon {
-    position: absolute;
-    top: 0;
-    left: 0;
-    margin-bottom: 0;
-    font-size: 30px;
-    -ms-flex-pack: center !important;
-    justify-content: center !important;
-    text-align: center;
-  }
-  &.style-2 p {
-    margin-left: -50px;
-  }
-  &.style-3 {
-    padding-left: 90px;
-    padding-top: 0px;
-    .featured-box-icon {
-      width: 70px;
-      height: 70px;
-      -ms-flex-negative: 0;
-      flex-shrink: 0;
-      display: -webkit-box;
-      display: -ms-flexbox;
-      display: flex;
-      -webkit-box-align: center;
-      -ms-flex-align: center;
-      align-items: center;
-    }
-  }
-  &.style-4 {
-    text-align: center;
-    .featured-box-icon {
-      margin: 0 auto 24px;
-      margin: 0 auto 1.5rem;
-      width: 120px;
-      height: 120px;
-      text-align: center;
-      -ms-flex-negative: 0;
-      flex-shrink: 0;
-      display: -webkit-box;
-      display: -ms-flexbox;
-      display: flex;
-      -webkit-box-align: center;
-      -ms-flex-align: center;
-      align-items: center;
-	  -ms-flex-pack: center;
-	  justify-content: center;
-	  @include box-shadow(0px 0px 50px rgba(0, 0, 0, 0.03));
-    }
-  }
-  
-  &.style-5 {
-  text-align: center;
-  background: #fff;
-  border: 1px solid #f0f2f3;
-  @include box-shadow(0px 2px 5px rgba(0, 0, 0, 0.05));
-  @include transition(all 0.3s ease-in-out);
-  &:hover {
-    border: 1px solid #ebeded;
-	@include box-shadow(0px 5px 1.5rem rgba(0, 0, 0, 0.15));
-  }
-  h3 {
-    background: #f1f5f6;
-    font-size: 16px;
-    padding: 8px 0;
-    margin-bottom: 0px;
-  }
-  .featured-box-icon {
-    font-size: 50px;
-    margin: 44px 0px;
-  }
-}
-}
-
-
-@mixin featured-box-reverse {
-	text-align:right;
-	&.style-1, &.style-2{
-		padding-right:50px;
-		padding-left:0px;
-		.featured-box-icon{
-			left:auto;
-			right:0px;
-		}
-	}
-	&.style-2 p{
-		margin-right: -50px;
-		margin-left:0;
-	}
-	&.style-3{
-		padding-left:0;
-		padding-right:90px;
-		.featured-box-icon{
-			left:auto;
-			right:0px;
-		}
-	}
-}
-
-.featured-box.featured-box-reverse{
-	@include featured-box-reverse;
-}
-
-@include media-breakpoint-up(xs) {
-	.featured-box.featured-box-reverse-sm{
-		@include featured-box-reverse;
-	}
-}
-
-@include media-breakpoint-up(sm) {
-	.featured-box.featured-box-reverse-md{
-		@include featured-box-reverse;
-	}
-}
-
-@include media-breakpoint-up(md) {
-	.featured-box.featured-box-reverse-lg{
-		@include featured-box-reverse;
-	}
-}
-@include media-breakpoint-up(lg) {
-	.featured-box.featured-box-reverse-xl{
-		@include featured-box-reverse;
-	}
-}