@binance/common 2.0.0 → 2.0.1

package/dist/index.js

@@ -1,1766 +1,1743 @@
-"use strict";
+//#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ALGO_REST_API_PROD_URL: () => ALGO_REST_API_PROD_URL,
-  BadRequestError: () => BadRequestError,
-  C2C_REST_API_PROD_URL: () => C2C_REST_API_PROD_URL,
-  CONVERT_REST_API_PROD_URL: () => CONVERT_REST_API_PROD_URL,
-  COPY_TRADING_REST_API_PROD_URL: () => COPY_TRADING_REST_API_PROD_URL,
-  CRYPTO_LOAN_REST_API_PROD_URL: () => CRYPTO_LOAN_REST_API_PROD_URL,
-  ConfigurationRestAPI: () => ConfigurationRestAPI,
-  ConfigurationWebsocketAPI: () => ConfigurationWebsocketAPI2,
-  ConfigurationWebsocketStreams: () => ConfigurationWebsocketStreams,
-  ConnectorClientError: () => ConnectorClientError,
-  DERIVATIVES_TRADING_COIN_FUTURES_REST_API_PROD_URL: () => DERIVATIVES_TRADING_COIN_FUTURES_REST_API_PROD_URL,
-  DERIVATIVES_TRADING_COIN_FUTURES_REST_API_TESTNET_URL: () => DERIVATIVES_TRADING_COIN_FUTURES_REST_API_TESTNET_URL,
-  DERIVATIVES_TRADING_COIN_FUTURES_WS_API_PROD_URL: () => DERIVATIVES_TRADING_COIN_FUTURES_WS_API_PROD_URL,
-  DERIVATIVES_TRADING_COIN_FUTURES_WS_API_TESTNET_URL: () => DERIVATIVES_TRADING_COIN_FUTURES_WS_API_TESTNET_URL,
-  DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_PROD_URL: () => DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_PROD_URL,
-  DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_TESTNET_URL: () => DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_TESTNET_URL,
-  DERIVATIVES_TRADING_OPTIONS_REST_API_PROD_URL: () => DERIVATIVES_TRADING_OPTIONS_REST_API_PROD_URL,
-  DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_PROD_URL: () => DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_PROD_URL,
-  DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_REST_API_PROD_URL: () => DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_REST_API_PROD_URL,
-  DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_WS_STREAMS_PROD_URL: () => DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_WS_STREAMS_PROD_URL,
-  DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_PROD_URL: () => DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_PROD_URL,
-  DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_TESTNET_URL: () => DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_TESTNET_URL,
-  DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_PROD_URL: () => DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_PROD_URL,
-  DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_TESTNET_URL: () => DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_TESTNET_URL,
-  DERIVATIVES_TRADING_USDS_FUTURES_REST_API_PROD_URL: () => DERIVATIVES_TRADING_USDS_FUTURES_REST_API_PROD_URL,
-  DERIVATIVES_TRADING_USDS_FUTURES_REST_API_TESTNET_URL: () => DERIVATIVES_TRADING_USDS_FUTURES_REST_API_TESTNET_URL,
-  DERIVATIVES_TRADING_USDS_FUTURES_WS_API_PROD_URL: () => DERIVATIVES_TRADING_USDS_FUTURES_WS_API_PROD_URL,
-  DERIVATIVES_TRADING_USDS_FUTURES_WS_API_TESTNET_URL: () => DERIVATIVES_TRADING_USDS_FUTURES_WS_API_TESTNET_URL,
-  DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_PROD_URL: () => DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_PROD_URL,
-  DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_TESTNET_URL: () => DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_TESTNET_URL,
-  DUAL_INVESTMENT_REST_API_PROD_URL: () => DUAL_INVESTMENT_REST_API_PROD_URL,
-  FIAT_REST_API_PROD_URL: () => FIAT_REST_API_PROD_URL,
-  ForbiddenError: () => ForbiddenError,
-  GIFT_CARD_REST_API_PROD_URL: () => GIFT_CARD_REST_API_PROD_URL,
-  LogLevel: () => LogLevel,
-  Logger: () => Logger,
-  MARGIN_TRADING_REST_API_PROD_URL: () => MARGIN_TRADING_REST_API_PROD_URL,
-  MARGIN_TRADING_RISK_WS_STREAMS_PROD_URL: () => MARGIN_TRADING_RISK_WS_STREAMS_PROD_URL,
-  MARGIN_TRADING_WS_STREAMS_PROD_URL: () => MARGIN_TRADING_WS_STREAMS_PROD_URL,
-  MINING_REST_API_PROD_URL: () => MINING_REST_API_PROD_URL,
-  NFT_REST_API_PROD_URL: () => NFT_REST_API_PROD_URL,
-  NetworkError: () => NetworkError,
-  NotFoundError: () => NotFoundError,
-  PAY_REST_API_PROD_URL: () => PAY_REST_API_PROD_URL,
-  REBATE_REST_API_PROD_URL: () => REBATE_REST_API_PROD_URL,
-  RateLimitBanError: () => RateLimitBanError,
-  RequiredError: () => RequiredError,
-  SIMPLE_EARN_REST_API_PROD_URL: () => SIMPLE_EARN_REST_API_PROD_URL,
-  SPOT_REST_API_MARKET_URL: () => SPOT_REST_API_MARKET_URL,
-  SPOT_REST_API_PROD_URL: () => SPOT_REST_API_PROD_URL,
-  SPOT_REST_API_TESTNET_URL: () => SPOT_REST_API_TESTNET_URL,
-  SPOT_WS_API_PROD_URL: () => SPOT_WS_API_PROD_URL,
-  SPOT_WS_API_TESTNET_URL: () => SPOT_WS_API_TESTNET_URL,
-  SPOT_WS_STREAMS_MARKET_URL: () => SPOT_WS_STREAMS_MARKET_URL,
-  SPOT_WS_STREAMS_PROD_URL: () => SPOT_WS_STREAMS_PROD_URL,
-  SPOT_WS_STREAMS_TESTNET_URL: () => SPOT_WS_STREAMS_TESTNET_URL,
-  STAKING_REST_API_PROD_URL: () => STAKING_REST_API_PROD_URL,
-  SUB_ACCOUNT_REST_API_PROD_URL: () => SUB_ACCOUNT_REST_API_PROD_URL,
-  ServerError: () => ServerError,
-  TimeUnit: () => TimeUnit,
-  TooManyRequestsError: () => TooManyRequestsError,
-  UnauthorizedError: () => UnauthorizedError,
-  VIP_LOAN_REST_API_PROD_URL: () => VIP_LOAN_REST_API_PROD_URL,
-  WALLET_REST_API_PROD_URL: () => WALLET_REST_API_PROD_URL,
-  WebsocketAPIBase: () => WebsocketAPIBase,
-  WebsocketCommon: () => WebsocketCommon,
-  WebsocketEventEmitter: () => WebsocketEventEmitter,
-  WebsocketStreamsBase: () => WebsocketStreamsBase,
-  assertParamExists: () => assertParamExists,
-  buildQueryString: () => buildQueryString,
-  buildUserAgent: () => buildUserAgent,
-  buildWebsocketAPIMessage: () => buildWebsocketAPIMessage,
-  clearSignerCache: () => clearSignerCache,
-  createStreamHandler: () => createStreamHandler,
-  delay: () => delay,
-  getSignature: () => getSignature,
-  getTimestamp: () => getTimestamp,
-  httpRequestFunction: () => httpRequestFunction,
-  normalizeScientificNumbers: () => normalizeScientificNumbers,
-  parseCustomHeaders: () => parseCustomHeaders,
-  parseRateLimitHeaders: () => parseRateLimitHeaders,
-  randomString: () => randomString,
-  removeEmptyValue: () => removeEmptyValue,
-  replaceWebsocketStreamsPlaceholders: () => replaceWebsocketStreamsPlaceholders,
-  sanitizeHeaderValue: () => sanitizeHeaderValue,
-  sendRequest: () => sendRequest,
-  setSearchParams: () => setSearchParams,
-  shouldRetryRequest: () => shouldRetryRequest,
-  sortObject: () => sortObject,
-  toPathString: () => toPathString,
-  validateTimeUnit: () => validateTimeUnit
-});
-module.exports = __toCommonJS(index_exports);
+//#endregion
+let crypto = require("crypto");
+crypto = __toESM(crypto);
+let fs = require("fs");
+fs = __toESM(fs);
+let https = require("https");
+https = __toESM(https);
+let json_with_bigint = require("json-with-bigint");
+let os = require("os");
+let axios = require("axios");
+axios = __toESM(axios);
+let events = require("events");
+let ws = require("ws");
+ws = __toESM(ws);
 
-// src/utils.ts
-var import_crypto = __toESM(require("crypto"));
-var import_fs = __toESM(require("fs"));
-var import_https = __toESM(require("https"));
-var import_json_with_bigint = require("json-with-bigint");
-var import_os = require("os");
-var import_axios = __toESM(require("axios"));
-var signerCache = /* @__PURE__ */ new WeakMap();
+//#region src/utils.ts
+/**
+* A weak cache for storing RequestSigner instances based on configuration parameters.
+*
+* @remarks
+* Uses a WeakMap to cache and reuse RequestSigner instances for configurations with
+* apiSecret, privateKey, and privateKeyPassphrase, allowing efficient memory management.
+*/
+let signerCache = /* @__PURE__ */ new WeakMap();
+/**
+* Represents a request signer for generating signatures using HMAC-SHA256 or asymmetric key signing.
+*
+* Supports two signing methods:
+* 1. HMAC-SHA256 using an API secret
+* 2. Asymmetric signing using RSA or ED25519 private keys
+*
+* @throws {Error} If neither API secret nor private key is provided, or if the private key is invalid
+*/
 var RequestSigner = class {
-  constructor(configuration) {
-    if (configuration.apiSecret && !configuration.privateKey) {
-      this.apiSecret = configuration.apiSecret;
-      return;
-    }
-    if (configuration.privateKey) {
-      let privateKey = configuration.privateKey;
-      if (typeof privateKey === "string" && import_fs.default.existsSync(privateKey)) {
-        privateKey = import_fs.default.readFileSync(privateKey, "utf-8");
-      }
-      const keyInput = { key: privateKey };
-      if (configuration.privateKeyPassphrase && typeof configuration.privateKeyPassphrase === "string") {
-        keyInput.passphrase = configuration.privateKeyPassphrase;
-      }
-      try {
-        this.keyObject = import_crypto.default.createPrivateKey(keyInput);
-        this.keyType = this.keyObject.asymmetricKeyType;
-      } catch {
-        throw new Error(
-          "Invalid private key. Please provide a valid RSA or ED25519 private key."
-        );
-      }
-      return;
-    }
-    throw new Error("Either 'apiSecret' or 'privateKey' must be provided for signed requests.");
-  }
-  sign(queryParams) {
-    const params = buildQueryString(queryParams);
-    if (this.apiSecret)
-      return import_crypto.default.createHmac("sha256", this.apiSecret).update(params).digest("hex");
-    if (this.keyObject && this.keyType) {
-      const data = Buffer.from(params);
-      if (this.keyType === "rsa")
-        return import_crypto.default.sign("RSA-SHA256", data, this.keyObject).toString("base64");
-      if (this.keyType === "ed25519")
-        return import_crypto.default.sign(null, data, this.keyObject).toString("base64");
-      throw new Error("Unsupported private key type. Must be RSA or ED25519.");
-    }
-    throw new Error("Signer is not properly initialized.");
-  }
+	constructor(configuration) {
+		if (configuration.apiSecret && !configuration.privateKey) {
+			this.apiSecret = configuration.apiSecret;
+			return;
+		}
+		if (configuration.privateKey) {
+			let privateKey = configuration.privateKey;
+			if (typeof privateKey === "string" && fs.default.existsSync(privateKey)) privateKey = fs.default.readFileSync(privateKey, "utf-8");
+			const keyInput = { key: privateKey };
+			if (configuration.privateKeyPassphrase && typeof configuration.privateKeyPassphrase === "string") keyInput.passphrase = configuration.privateKeyPassphrase;
+			try {
+				this.keyObject = crypto.default.createPrivateKey(keyInput);
+				this.keyType = this.keyObject.asymmetricKeyType;
+			} catch {
+				throw new Error("Invalid private key. Please provide a valid RSA or ED25519 private key.");
+			}
+			return;
+		}
+		throw new Error("Either 'apiSecret' or 'privateKey' must be provided for signed requests.");
+	}
+	sign(queryParams) {
+		const params = buildQueryString(queryParams);
+		if (this.apiSecret) return crypto.default.createHmac("sha256", this.apiSecret).update(params).digest("hex");
+		if (this.keyObject && this.keyType) {
+			const data = Buffer.from(params);
+			if (this.keyType === "rsa") return crypto.default.sign("RSA-SHA256", data, this.keyObject).toString("base64");
+			if (this.keyType === "ed25519") return crypto.default.sign(null, data, this.keyObject).toString("base64");
+			throw new Error("Unsupported private key type. Must be RSA or ED25519.");
+		}
+		throw new Error("Signer is not properly initialized.");
+	}
 };
-var clearSignerCache = function() {
-  signerCache = /* @__PURE__ */ new WeakMap();
+/**
+* Resets the signer cache to a new empty WeakMap.
+*
+* This function clears the existing signer cache, creating a fresh WeakMap
+* to store RequestSigner instances associated with configuration objects.
+*/
+const clearSignerCache = function() {
+	signerCache = /* @__PURE__ */ new WeakMap();
 };
+/**
+* Serializes a value to a string representation.
+*
+* - If the value is `null` or `undefined`, returns an empty string.
+* - If the value is an array or a non-null object, returns its JSON string representation.
+* - Otherwise, converts the value to a string using `String()`.
+*
+* @param value - The value to serialize.
+* @returns The serialized string representation of the value.
+*/
 function serializeValue(value) {
-  if (value === null || value === void 0) return "";
-  if (Array.isArray(value) || typeof value === "object" && value !== null)
-    return JSON.stringify(value);
-  return String(value);
+	if (value === null || value === void 0) return "";
+	if (Array.isArray(value) || typeof value === "object" && value !== null) return JSON.stringify(value);
+	return String(value);
 }
+/**
+* Builds a URL query string from the given parameters object.
+*
+* Iterates over the key-value pairs in the `params` object, serializes each value,
+* and encodes it for use in a URL. Only keys with non-null and non-undefined values
+* are included in the resulting query string.
+*
+* @param params - An object containing key-value pairs to be serialized into a query string.
+* @returns A URL-encoded query string representing the provided parameters.
+*/
 function buildQueryString(params) {
-  if (!params) return "";
-  const pairs = [];
-  Object.entries(params).forEach(([key, value]) => {
-    if (value !== null && value !== void 0) {
-      const serializedValue = serializeValue(value);
-      pairs.push(`${key}=${encodeURIComponent(serializedValue)}`);
-    }
-  });
-  return pairs.join("&");
+	if (!params) return "";
+	const pairs = [];
+	Object.entries(params).forEach(([key, value]) => {
+		if (value !== null && value !== void 0) {
+			const serializedValue = serializeValue(value);
+			pairs.push(`${key}=${encodeURIComponent(serializedValue)}`);
+		}
+	});
+	return pairs.join("&");
 }
+/**
+* Generates a random string of 16 hexadecimal characters.
+*
+* @returns A random string of 16 hexadecimal characters.
+*/
 function randomString() {
-  return import_crypto.default.randomBytes(16).toString("hex");
+	return crypto.default.randomBytes(16).toString("hex");
 }
+/**
+* Validates the provided time unit string and returns it if it is either 'MILLISECOND' or 'MICROSECOND'.
+*
+* @param timeUnit - The time unit string to be validated.
+* @returns The validated time unit string, or `undefined` if the input is falsy.
+* @throws {Error} If the time unit is not 'MILLISECOND' or 'MICROSECOND'.
+*/
 function validateTimeUnit(timeUnit) {
-  if (!timeUnit) {
-    return;
-  } else if (timeUnit !== TimeUnit.MILLISECOND && timeUnit !== TimeUnit.MICROSECOND && timeUnit !== TimeUnit.millisecond && timeUnit !== TimeUnit.microsecond) {
-    throw new Error("timeUnit must be either 'MILLISECOND' or 'MICROSECOND'");
-  }
-  return timeUnit;
+	if (!timeUnit) return;
+	else if (timeUnit !== TimeUnit.MILLISECOND && timeUnit !== TimeUnit.MICROSECOND && timeUnit !== TimeUnit.millisecond && timeUnit !== TimeUnit.microsecond) throw new Error("timeUnit must be either 'MILLISECOND' or 'MICROSECOND'");
+	return timeUnit;
 }
+/**
+* Delays the execution of the current function for the specified number of milliseconds.
+*
+* @param ms - The number of milliseconds to delay the function.
+* @returns A Promise that resolves after the specified delay.
+*/
 async function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+	return new Promise((resolve) => setTimeout(resolve, ms));
 }
+/**
+* Generates the current timestamp in milliseconds.
+*
+* @returns The current timestamp in milliseconds.
+*/
 function getTimestamp() {
-  return Date.now();
+	return Date.now();
 }
-var getSignature = function(configuration, queryParams) {
-  let signer = signerCache.get(configuration);
-  if (!signer) {
-    signer = new RequestSigner(configuration);
-    signerCache.set(configuration, signer);
-  }
-  return signer.sign(queryParams);
+/**
+* Generates a signature for the given configuration and query parameters using a cached request signer.
+*
+* @param configuration - Configuration object containing API secret, private key, and optional passphrase.
+* @param queryParams - The query parameters to be signed.
+* @returns A string representing the generated signature.
+*/
+const getSignature = function(configuration, queryParams) {
+	let signer = signerCache.get(configuration);
+	if (!signer) {
+		signer = new RequestSigner(configuration);
+		signerCache.set(configuration, signer);
+	}
+	return signer.sign(queryParams);
 };
-var assertParamExists = function(functionName, paramName, paramValue) {
-  if (paramValue === null || paramValue === void 0) {
-    throw new RequiredError(
-      paramName,
-      `Required parameter ${paramName} was null or undefined when calling ${functionName}.`
-    );
-  }
+/**
+* Asserts that a function parameter exists and is not null or undefined.
+*
+* @param functionName - The name of the function that the parameter belongs to.
+* @param paramName - The name of the parameter to check.
+* @param paramValue - The value of the parameter to check.
+* @throws {RequiredError} If the parameter is null or undefined.
+*/
+const assertParamExists = function(functionName, paramName, paramValue) {
+	if (paramValue === null || paramValue === void 0) throw new RequiredError(paramName, `Required parameter ${paramName} was null or undefined when calling ${functionName}.`);
 };
+/**
+* Sets the search parameters of a given URL object based on the provided key-value pairs.
+* Only parameters with non-null and non-undefined values are included.
+* Values are serialized using the `serializeValue` function before being set.
+*
+* @param url - The URL object whose search parameters will be updated.
+* @param params - An object containing key-value pairs to be set as search parameters.
+*/
 function setSearchParams(url, params) {
-  const searchParams = new URLSearchParams();
-  Object.entries(params).forEach(([key, value]) => {
-    if (value !== null && value !== void 0) {
-      const serializedValue = serializeValue(value);
-      searchParams.set(key, serializedValue);
-    }
-  });
-  url.search = searchParams.toString();
+	const searchParams = new URLSearchParams();
+	Object.entries(params).forEach(([key, value]) => {
+		if (value !== null && value !== void 0) {
+			const serializedValue = serializeValue(value);
+			searchParams.set(key, serializedValue);
+		}
+	});
+	url.search = searchParams.toString();
 }
-var toPathString = function(url) {
-  return url.pathname + url.search + url.hash;
+/**
+* Converts a URL object to a full path string, including pathname, search parameters, and hash.
+*
+* @param url The URL object to convert to a path string.
+* @returns A complete path string representation of the URL.
+*/
+const toPathString = function(url) {
+	return url.pathname + url.search + url.hash;
 };
+/**
+* Normalizes scientific notation numbers in an object or array to a fixed number of decimal places.
+*
+* This function recursively processes objects, arrays, and numbers, converting scientific notation
+* to a fixed decimal representation. Non-numeric values are left unchanged.
+*
+* @template T The type of the input object or value
+* @param obj The object, array, or value to normalize
+* @returns A new object or value with scientific notation numbers normalized
+*/
 function normalizeScientificNumbers(obj) {
-  if (Array.isArray(obj)) {
-    return obj.map((item) => normalizeScientificNumbers(item));
-  } else if (typeof obj === "object" && obj !== null) {
-    const result = {};
-    for (const key of Object.keys(obj)) {
-      result[key] = normalizeScientificNumbers(obj[key]);
-    }
-    return result;
-  } else if (typeof obj === "number") {
-    if (!Number.isFinite(obj)) return obj;
-    const abs = Math.abs(obj);
-    if (abs === 0 || abs >= 1e-6 && abs < 1e21) return String(obj);
-    const isNegative = obj < 0;
-    const [rawMantissa, rawExponent] = abs.toExponential().split("e");
-    const exponent = +rawExponent;
-    const digits = rawMantissa.replace(".", "");
-    if (exponent < 0) {
-      const zeros = "0".repeat(Math.abs(exponent) - 1);
-      return (isNegative ? "-" : "") + "0." + zeros + digits;
-    } else {
-      const pad = exponent - (digits.length - 1);
-      if (pad >= 0) {
-        return (isNegative ? "-" : "") + digits + "0".repeat(pad);
-      } else {
-        const point = digits.length + pad;
-        return (isNegative ? "-" : "") + digits.slice(0, point) + "." + digits.slice(point);
-      }
-    }
-  } else {
-    return obj;
-  }
+	if (Array.isArray(obj)) return obj.map((item) => normalizeScientificNumbers(item));
+	else if (typeof obj === "object" && obj !== null) {
+		const result = {};
+		for (const key of Object.keys(obj)) result[key] = normalizeScientificNumbers(obj[key]);
+		return result;
+	} else if (typeof obj === "number") {
+		if (!Number.isFinite(obj)) return obj;
+		const abs = Math.abs(obj);
+		if (abs === 0 || abs >= 1e-6 && abs < 1e21) return String(obj);
+		const isNegative = obj < 0;
+		const [rawMantissa, rawExponent] = abs.toExponential().split("e");
+		const exponent = +rawExponent;
+		const digits = rawMantissa.replace(".", "");
+		if (exponent < 0) {
+			const zeros = "0".repeat(Math.abs(exponent) - 1);
+			return (isNegative ? "-" : "") + "0." + zeros + digits;
+		} else {
+			const pad = exponent - (digits.length - 1);
+			if (pad >= 0) return (isNegative ? "-" : "") + digits + "0".repeat(pad);
+			else {
+				const point = digits.length + pad;
+				return (isNegative ? "-" : "") + digits.slice(0, point) + "." + digits.slice(point);
+			}
+		}
+	} else return obj;
 }
-var shouldRetryRequest = function(error, method, retriesLeft) {
-  const isRetriableMethod = ["GET", "DELETE"].includes(method ?? "");
-  const isRetriableStatus = [500, 502, 503, 504].includes(
-    error?.response?.status ?? 0
-  );
-  return (retriesLeft ?? 0) > 0 && isRetriableMethod && (isRetriableStatus || !error?.response);
+/**
+* Determines whether a request should be retried based on the provided error.
+*
+* This function checks the HTTP method, response status, and number of retries left to determine if a request should be retried.
+*
+* @param error The error object to check.
+* @param method The HTTP method of the request (optional).
+* @param retriesLeft The number of retries left (optional).
+* @returns `true` if the request should be retried, `false` otherwise.
+*/
+const shouldRetryRequest = function(error, method, retriesLeft) {
+	const isRetriableMethod = ["GET", "DELETE"].includes(method ?? "");
+	const isRetriableStatus = [
+		500,
+		502,
+		503,
+		504
+	].includes(error?.response?.status ?? 0);
+	return (retriesLeft ?? 0) > 0 && isRetriableMethod && (isRetriableStatus || !error?.response);
 };
-var httpRequestFunction = async function(axiosArgs, configuration) {
-  const axiosRequestArgs = {
-    ...axiosArgs.options,
-    url: (import_axios.default.defaults?.baseURL ? "" : configuration?.basePath ?? "") + axiosArgs.url
-  };
-  if (configuration?.keepAlive && !configuration?.baseOptions?.httpsAgent)
-    axiosRequestArgs.httpsAgent = new import_https.default.Agent({ keepAlive: true });
-  if (configuration?.compression)
-    axiosRequestArgs.headers = {
-      ...axiosRequestArgs.headers,
-      "Accept-Encoding": "gzip, deflate, br"
-    };
-  const retries = configuration?.retries ?? 0;
-  const backoff = configuration?.backoff ?? 0;
-  let attempt = 0;
-  let lastError;
-  while (attempt <= retries) {
-    try {
-      const response = await import_axios.default.request({
-        ...axiosRequestArgs,
-        responseType: "text"
-      });
-      const rateLimits = parseRateLimitHeaders(response.headers);
-      return {
-        data: async () => {
-          try {
-            return (0, import_json_with_bigint.JSONParse)(response.data);
-          } catch (err) {
-            throw new Error(`Failed to parse JSON response: ${err}`);
-          }
-        },
-        status: response.status,
-        headers: response.headers,
-        rateLimits
-      };
-    } catch (error) {
-      attempt++;
-      const axiosError = error;
-      if (shouldRetryRequest(
-        axiosError,
-        axiosRequestArgs?.method?.toUpperCase(),
-        retries - attempt
-      )) {
-        await delay(backoff * attempt);
-      } else {
-        if (axiosError.response && axiosError.response.status) {
-          const status = axiosError.response?.status;
-          const responseData = axiosError.response.data;
-          let data = {};
-          if (responseData && responseData !== null) {
-            if (typeof responseData === "string" && responseData !== "")
-              try {
-                data = (0, import_json_with_bigint.JSONParse)(responseData);
-              } catch {
-                data = {};
-              }
-            else if (typeof responseData === "object")
-              data = responseData;
-          }
-          const errorMsg = data.msg;
-          switch (status) {
-            case 400:
-              throw new BadRequestError(errorMsg);
-            case 401:
-              throw new UnauthorizedError(errorMsg);
-            case 403:
-              throw new ForbiddenError(errorMsg);
-            case 404:
-              throw new NotFoundError(errorMsg);
-            case 418:
-              throw new RateLimitBanError(errorMsg);
-            case 429:
-              throw new TooManyRequestsError(errorMsg);
-            default:
-              if (status >= 500 && status < 600)
-                throw new ServerError(`Server error: ${status}`, status);
-              throw new ConnectorClientError(errorMsg);
-          }
-        } else {
-          if (retries > 0 && attempt >= retries)
-            lastError = new Error(`Request failed after ${retries} retries`);
-          else lastError = new NetworkError("Network error or request timeout.");
-          break;
-        }
-      }
-    }
-  }
-  throw lastError;
+/**
+* Performs an HTTP request using the provided Axios instance and configuration.
+*
+* This function handles retries, rate limit handling, and error handling for the HTTP request.
+*
+* @param axiosArgs The request arguments to be passed to Axios.
+* @param configuration The configuration options for the request.
+* @returns A Promise that resolves to the API response, including the data and rate limit headers.
+*/
+const httpRequestFunction = async function(axiosArgs, configuration) {
+	const axiosRequestArgs = {
+		...axiosArgs.options,
+		url: (axios.default.defaults?.baseURL ? "" : configuration?.basePath ?? "") + axiosArgs.url
+	};
+	if (configuration?.keepAlive && !configuration?.baseOptions?.httpsAgent) axiosRequestArgs.httpsAgent = new https.default.Agent({ keepAlive: true });
+	if (configuration?.compression) axiosRequestArgs.headers = {
+		...axiosRequestArgs.headers,
+		"Accept-Encoding": "gzip, deflate, br"
+	};
+	const retries = configuration?.retries ?? 0;
+	const backoff = configuration?.backoff ?? 0;
+	let attempt = 0;
+	let lastError;
+	while (attempt <= retries) try {
+		const response = await axios.default.request({
+			...axiosRequestArgs,
+			responseType: "text"
+		});
+		const rateLimits = parseRateLimitHeaders(response.headers);
+		return {
+			data: async () => {
+				try {
+					return (0, json_with_bigint.JSONParse)(response.data);
+				} catch (err) {
+					throw new Error(`Failed to parse JSON response: ${err}`);
+				}
+			},
+			status: response.status,
+			headers: response.headers,
+			rateLimits
+		};
+	} catch (error) {
+		attempt++;
+		const axiosError = error;
+		if (shouldRetryRequest(axiosError, axiosRequestArgs?.method?.toUpperCase(), retries - attempt)) await delay(backoff * attempt);
+		else if (axiosError.response && axiosError.response.status) {
+			const status = axiosError.response?.status;
+			const responseData = axiosError.response.data;
+			let data = {};
+			if (responseData && responseData !== null) {
+				if (typeof responseData === "string" && responseData !== "") try {
+					data = (0, json_with_bigint.JSONParse)(responseData);
+				} catch {
+					data = {};
+				}
+				else if (typeof responseData === "object") data = responseData;
+			}
+			const errorMsg = data.msg;
+			switch (status) {
+				case 400: throw new BadRequestError(errorMsg);
+				case 401: throw new UnauthorizedError(errorMsg);
+				case 403: throw new ForbiddenError(errorMsg);
+				case 404: throw new NotFoundError(errorMsg);
+				case 418: throw new RateLimitBanError(errorMsg);
+				case 429: throw new TooManyRequestsError(errorMsg);
+				default:
+					if (status >= 500 && status < 600) throw new ServerError(`Server error: ${status}`, status);
+					throw new ConnectorClientError(errorMsg);
+			}
+		} else {
+			if (retries > 0 && attempt >= retries) lastError = /* @__PURE__ */ new Error(`Request failed after ${retries} retries`);
+			else lastError = new NetworkError("Network error or request timeout.");
+			break;
+		}
+	}
+	throw lastError;
 };
-var parseRateLimitHeaders = function(headers) {
-  const rateLimits = [];
-  const parseIntervalDetails = (key) => {
-    const match = key.match(/x-mbx-used-weight-(\d+)([smhd])|x-mbx-order-count-(\d+)([smhd])/i);
-    if (!match) return null;
-    const intervalNum = parseInt(match[1] || match[3], 10);
-    const intervalLetter = (match[2] || match[4])?.toUpperCase();
-    let interval;
-    switch (intervalLetter) {
-      case "S":
-        interval = "SECOND";
-        break;
-      case "M":
-        interval = "MINUTE";
-        break;
-      case "H":
-        interval = "HOUR";
-        break;
-      case "D":
-        interval = "DAY";
-        break;
-      default:
-        return null;
-    }
-    return { interval, intervalNum };
-  };
-  for (const [key, value] of Object.entries(headers)) {
-    const normalizedKey = key.toLowerCase();
-    if (value === void 0) continue;
-    if (normalizedKey.startsWith("x-mbx-used-weight-")) {
-      const details = parseIntervalDetails(normalizedKey);
-      if (details) {
-        rateLimits.push({
-          rateLimitType: "REQUEST_WEIGHT",
-          interval: details.interval,
-          intervalNum: details.intervalNum,
-          count: parseInt(value, 10)
-        });
-      }
-    } else if (normalizedKey.startsWith("x-mbx-order-count-")) {
-      const details = parseIntervalDetails(normalizedKey);
-      if (details) {
-        rateLimits.push({
-          rateLimitType: "ORDERS",
-          interval: details.interval,
-          intervalNum: details.intervalNum,
-          count: parseInt(value, 10)
-        });
-      }
-    }
-  }
-  if (headers["retry-after"]) {
-    const retryAfter = parseInt(headers["retry-after"], 10);
-    for (const limit of rateLimits) {
-      limit.retryAfter = retryAfter;
-    }
-  }
-  return rateLimits;
+/**
+* Parses the rate limit headers from the Axios response headers and returns an array of `RestApiRateLimit` objects.
+*
+* @param headers - The Axios response headers.
+* @returns An array of `RestApiRateLimit` objects containing the parsed rate limit information.
+*/
+const parseRateLimitHeaders = function(headers) {
+	const rateLimits = [];
+	const parseIntervalDetails = (key) => {
+		const match = key.match(/x-mbx-used-weight-(\d+)([smhd])|x-mbx-order-count-(\d+)([smhd])/i);
+		if (!match) return null;
+		const intervalNum = parseInt(match[1] || match[3], 10);
+		const intervalLetter = (match[2] || match[4])?.toUpperCase();
+		let interval;
+		switch (intervalLetter) {
+			case "S":
+				interval = "SECOND";
+				break;
+			case "M":
+				interval = "MINUTE";
+				break;
+			case "H":
+				interval = "HOUR";
+				break;
+			case "D":
+				interval = "DAY";
+				break;
+			default: return null;
+		}
+		return {
+			interval,
+			intervalNum
+		};
+	};
+	for (const [key, value] of Object.entries(headers)) {
+		const normalizedKey = key.toLowerCase();
+		if (value === void 0) continue;
+		if (normalizedKey.startsWith("x-mbx-used-weight-")) {
+			const details = parseIntervalDetails(normalizedKey);
+			if (details) rateLimits.push({
+				rateLimitType: "REQUEST_WEIGHT",
+				interval: details.interval,
+				intervalNum: details.intervalNum,
+				count: parseInt(value, 10)
+			});
+		} else if (normalizedKey.startsWith("x-mbx-order-count-")) {
+			const details = parseIntervalDetails(normalizedKey);
+			if (details) rateLimits.push({
+				rateLimitType: "ORDERS",
+				interval: details.interval,
+				intervalNum: details.intervalNum,
+				count: parseInt(value, 10)
+			});
+		}
+	}
+	if (headers["retry-after"]) {
+		const retryAfter = parseInt(headers["retry-after"], 10);
+		for (const limit of rateLimits) limit.retryAfter = retryAfter;
+	}
+	return rateLimits;
 };
-var sendRequest = function(configuration, endpoint, method, params = {}, timeUnit, options = {}) {
-  const localVarUrlObj = new URL(endpoint, configuration?.basePath);
-  const localVarRequestOptions = {
-    method,
-    ...configuration?.baseOptions
-  };
-  const localVarQueryParameter = { ...normalizeScientificNumbers(params) };
-  if (options.isSigned) {
-    const timestamp = getTimestamp();
-    localVarQueryParameter["timestamp"] = timestamp;
-    const signature = getSignature(configuration, localVarQueryParameter);
-    if (signature) {
-      localVarQueryParameter["signature"] = signature;
-    }
-  }
-  setSearchParams(localVarUrlObj, localVarQueryParameter);
-  if (timeUnit && localVarRequestOptions.headers) {
-    const _timeUnit = validateTimeUnit(timeUnit);
-    localVarRequestOptions.headers = {
-      ...localVarRequestOptions.headers,
-      "X-MBX-TIME-UNIT": _timeUnit
-    };
-  }
-  return httpRequestFunction(
-    {
-      url: toPathString(localVarUrlObj),
-      options: localVarRequestOptions
-    },
-    configuration
-  );
+/**
+* Generic function to send a request with optional API key and signature.
+* @param endpoint - The API endpoint to call.
+* @param method - HTTP method to use (GET, POST, DELETE, etc.).
+* @param params - Query parameters for the request.
+* @param timeUnit - The time unit for the request.
+* @param options - Additional request options (isSigned).
+* @returns A promise resolving to the response data object.
+*/
+const sendRequest = function(configuration, endpoint, method, params = {}, timeUnit, options = {}) {
+	const localVarUrlObj = new URL(endpoint, configuration?.basePath);
+	const localVarRequestOptions = {
+		method,
+		...configuration?.baseOptions
+	};
+	const localVarQueryParameter = { ...normalizeScientificNumbers(params) };
+	if (options.isSigned) {
+		localVarQueryParameter["timestamp"] = getTimestamp();
+		const signature = getSignature(configuration, localVarQueryParameter);
+		if (signature) localVarQueryParameter["signature"] = signature;
+	}
+	setSearchParams(localVarUrlObj, localVarQueryParameter);
+	if (timeUnit && localVarRequestOptions.headers) {
+		const _timeUnit = validateTimeUnit(timeUnit);
+		localVarRequestOptions.headers = {
+			...localVarRequestOptions.headers,
+			"X-MBX-TIME-UNIT": _timeUnit
+		};
+	}
+	return httpRequestFunction({
+		url: toPathString(localVarUrlObj),
+		options: localVarRequestOptions
+	}, configuration);
 };
+/**
+* Removes any null, undefined, or empty string values from the provided object.
+*
+* @param obj - The object to remove empty values from.
+* @returns A new object with empty values removed.
+*/
 function removeEmptyValue(obj) {
-  if (!(obj instanceof Object)) return {};
-  return Object.fromEntries(
-    Object.entries(obj).filter(
-      ([, value]) => value !== null && value !== void 0 && value !== ""
-    )
-  );
+	if (!(obj instanceof Object)) return {};
+	return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== null && value !== void 0 && value !== ""));
 }
+/**
+* Sorts the properties of the provided object in alphabetical order and returns a new object with the sorted properties.
+*
+* @param obj - The object to be sorted.
+* @returns A new object with the properties sorted in alphabetical order.
+*/
 function sortObject(obj) {
-  return Object.keys(obj).sort().reduce((res, key) => {
-    res[key] = obj[key];
-    return res;
-  }, {});
+	return Object.keys(obj).sort().reduce((res, key) => {
+		res[key] = obj[key];
+		return res;
+	}, {});
 }
+/**
+* Replaces placeholders in the format <field> with corresponding values from the provided variables object.
+*
+* @param {string} str - The input string containing placeholders.
+* @param {Object} variables - An object where keys correspond to placeholder names and values are the replacements.
+* @returns {string} - The resulting string with placeholders replaced by their corresponding values.
+*/
 function replaceWebsocketStreamsPlaceholders(str, variables) {
-  const normalizedVariables = Object.keys(variables).reduce(
-    (acc, key) => {
-      const normalizedKey = key.toLowerCase().replace(/[-_]/g, "");
-      acc[normalizedKey] = variables[key];
-      return acc;
-    },
-    {}
-  );
-  return str.replace(/(@)?<([^>]+)>/g, (match, precedingAt, fieldName) => {
-    const normalizedFieldName = fieldName.toLowerCase().replace(/[-_]/g, "");
-    if (Object.prototype.hasOwnProperty.call(normalizedVariables, normalizedFieldName) && normalizedVariables[normalizedFieldName] != null) {
-      const value = normalizedVariables[normalizedFieldName];
-      switch (normalizedFieldName) {
-        case "symbol":
-        case "windowsize":
-          return value.toLowerCase();
-        case "updatespeed":
-          return `@${value}`;
-        default:
-          return (precedingAt || "") + value;
-      }
-    }
-    return "";
-  });
+	const normalizedVariables = Object.keys(variables).reduce((acc, key) => {
+		const normalizedKey = key.toLowerCase().replace(/[-_]/g, "");
+		acc[normalizedKey] = variables[key];
+		return acc;
+	}, {});
+	return str.replace(/(@)?<([^>]+)>/g, (match, precedingAt, fieldName) => {
+		const normalizedFieldName = fieldName.toLowerCase().replace(/[-_]/g, "");
+		if (Object.prototype.hasOwnProperty.call(normalizedVariables, normalizedFieldName) && normalizedVariables[normalizedFieldName] != null) {
+			const value = normalizedVariables[normalizedFieldName];
+			switch (normalizedFieldName) {
+				case "symbol":
+				case "windowsize": return value.toLowerCase();
+				case "updatespeed": return `@${value}`;
+				default: return (precedingAt || "") + value;
+			}
+		}
+		return "";
+	});
 }
+/**
+* Generates a standardized user agent string for the application.
+*
+* @param {string} packageName - The name of the package/application.
+* @param {string} packageVersion - The version of the package/application.
+* @returns {string} A formatted user agent string including package details, Node.js version, platform, and architecture.
+*/
 function buildUserAgent(packageName, packageVersion) {
-  return `${packageName}/${packageVersion} (Node.js/${process.version}; ${(0, import_os.platform)()}; ${(0, import_os.arch)()})`;
+	return `${packageName}/${packageVersion} (Node.js/${process.version}; ${(0, os.platform)()}; ${(0, os.arch)()})`;
 }
+/**
+* Builds a WebSocket API message with optional authentication and signature.
+*
+* @param {ConfigurationWebsocketAPI} configuration - The WebSocket API configuration.
+* @param {string} method - The method name for the WebSocket message.
+* @param {WebsocketSendMsgOptions} payload - The payload data to be sent.
+* @param {WebsocketSendMsgConfig} options - Configuration options for message sending.
+* @param {boolean} [skipAuth=false] - Flag to skip authentication if needed.
+* @returns {Object} A structured WebSocket message with id, method, and params.
+*/
 function buildWebsocketAPIMessage(configuration, method, payload, options, skipAuth = false) {
-  const id = payload.id && /^[0-9a-f]{32}$/.test(payload.id) ? payload.id : randomString();
-  delete payload.id;
-  let params = normalizeScientificNumbers(removeEmptyValue(payload));
-  if ((options.withApiKey || options.isSigned) && !skipAuth) params.apiKey = configuration.apiKey;
-  if (options.isSigned) {
-    params.timestamp = getTimestamp();
-    params = sortObject(params);
-    if (!skipAuth) params.signature = getSignature(configuration, params);
-  }
-  return { id, method, params };
+	const id = payload.id && /^[0-9a-f]{32}$/.test(payload.id) ? payload.id : randomString();
+	delete payload.id;
+	let params = normalizeScientificNumbers(removeEmptyValue(payload));
+	if ((options.withApiKey || options.isSigned) && !skipAuth) params.apiKey = configuration.apiKey;
+	if (options.isSigned) {
+		params.timestamp = getTimestamp();
+		params = sortObject(params);
+		if (!skipAuth) params.signature = getSignature(configuration, params);
+	}
+	return {
+		id,
+		method,
+		params
+	};
 }
+/**
+* Sanitizes a header value by checking for and preventing carriage return and line feed characters.
+*
+* @param {string | string[]} value - The header value or array of header values to sanitize.
+* @returns {string | string[]} The sanitized header value(s).
+* @throws {Error} If the header value contains CR/LF characters.
+*/
 function sanitizeHeaderValue(value) {
-  const sanitizeOne = (v) => {
-    if (/\r|\n/.test(v)) throw new Error(`Invalid header value (contains CR/LF): "${v}"`);
-    return v;
-  };
-  return Array.isArray(value) ? value.map(sanitizeOne) : sanitizeOne(value);
+	const sanitizeOne = (v) => {
+		if (/\r|\n/.test(v)) throw new Error(`Invalid header value (contains CR/LF): "${v}"`);
+		return v;
+	};
+	return Array.isArray(value) ? value.map(sanitizeOne) : sanitizeOne(value);
 }
+/**
+* Parses and sanitizes custom headers, filtering out forbidden headers.
+*
+* @param {Record<string, string | string[]>} headers - The input headers to be parsed.
+* @returns {Record<string, string | string[]>} A new object with sanitized and allowed headers.
+* @description Removes forbidden headers like 'host', 'authorization', and 'cookie',
+* and sanitizes remaining header values to prevent injection of carriage return or line feed characters.
+*/
 function parseCustomHeaders(headers) {
-  if (!headers || Object.keys(headers).length === 0) return {};
-  const forbidden = /* @__PURE__ */ new Set(["host", "authorization", "cookie", ":method", ":path"]);
-  const parsedHeaders = {};
-  for (const [rawName, rawValue] of Object.entries(headers || {})) {
-    const name = rawName.trim();
-    if (forbidden.has(name.toLowerCase())) {
-      Logger.getInstance().warn(`Dropping forbidden header: ${name}`);
-      continue;
-    }
-    try {
-      parsedHeaders[name] = sanitizeHeaderValue(rawValue);
-    } catch {
-      continue;
-    }
-  }
-  return parsedHeaders;
+	if (!headers || Object.keys(headers).length === 0) return {};
+	const forbidden = new Set([
+		"host",
+		"authorization",
+		"cookie",
+		":method",
+		":path"
+	]);
+	const parsedHeaders = {};
+	for (const [rawName, rawValue] of Object.entries(headers || {})) {
+		const name = rawName.trim();
+		if (forbidden.has(name.toLowerCase())) {
+			Logger.getInstance().warn(`Dropping forbidden header: ${name}`);
+			continue;
+		}
+		try {
+			parsedHeaders[name] = sanitizeHeaderValue(rawValue);
+		} catch {
+			continue;
+		}
+	}
+	return parsedHeaders;
 }
 
-// src/configuration.ts
+//#endregion
+//#region src/configuration.ts
 var ConfigurationRestAPI = class {
-  constructor(param = { apiKey: "" }) {
-    this.apiKey = param.apiKey;
-    this.apiSecret = param.apiSecret;
-    this.basePath = param.basePath;
-    this.keepAlive = param.keepAlive ?? true;
-    this.compression = param.compression ?? true;
-    this.retries = param.retries ?? 3;
-    this.backoff = param.backoff ?? 1e3;
-    this.privateKey = param.privateKey;
-    this.privateKeyPassphrase = param.privateKeyPassphrase;
-    this.timeUnit = param.timeUnit;
-    this.baseOptions = {
-      timeout: param.timeout ?? 1e3,
-      proxy: param.proxy && {
-        host: param.proxy.host,
-        port: param.proxy.port,
-        ...param.proxy.protocol && { protocol: param.proxy.protocol },
-        ...param.proxy.auth && { auth: param.proxy.auth }
-      },
-      httpsAgent: param.httpsAgent ?? false,
-      headers: {
-        ...parseCustomHeaders(param.customHeaders || {}),
-        "Content-Type": "application/json",
-        "X-MBX-APIKEY": param.apiKey
-      }
-    };
-  }
+	constructor(param = { apiKey: "" }) {
+		this.apiKey = param.apiKey;
+		this.apiSecret = param.apiSecret;
+		this.basePath = param.basePath;
+		this.keepAlive = param.keepAlive ?? true;
+		this.compression = param.compression ?? true;
+		this.retries = param.retries ?? 3;
+		this.backoff = param.backoff ?? 1e3;
+		this.privateKey = param.privateKey;
+		this.privateKeyPassphrase = param.privateKeyPassphrase;
+		this.timeUnit = param.timeUnit;
+		this.baseOptions = {
+			timeout: param.timeout ?? 1e3,
+			proxy: param.proxy && {
+				host: param.proxy.host,
+				port: param.proxy.port,
+				...param.proxy.protocol && { protocol: param.proxy.protocol },
+				...param.proxy.auth && { auth: param.proxy.auth }
+			},
+			httpsAgent: param.httpsAgent ?? false,
+			headers: {
+				...parseCustomHeaders(param.customHeaders || {}),
+				"Content-Type": "application/json",
+				"X-MBX-APIKEY": param.apiKey
+			}
+		};
+	}
 };
-var ConfigurationWebsocketAPI2 = class {
-  constructor(param = { apiKey: "" }) {
-    this.apiKey = param.apiKey;
-    this.apiSecret = param.apiSecret;
-    this.wsURL = param.wsURL;
-    this.timeout = param.timeout ?? 5e3;
-    this.reconnectDelay = param.reconnectDelay ?? 5e3;
-    this.compression = param.compression ?? true;
-    this.agent = param.agent ?? false;
-    this.mode = param.mode ?? "single";
-    this.poolSize = param.poolSize ?? 1;
-    this.privateKey = param.privateKey;
-    this.privateKeyPassphrase = param.privateKeyPassphrase;
-    this.timeUnit = param.timeUnit;
-    this.autoSessionReLogon = param.autoSessionReLogon ?? true;
-  }
+var ConfigurationWebsocketAPI = class {
+	constructor(param = { apiKey: "" }) {
+		this.apiKey = param.apiKey;
+		this.apiSecret = param.apiSecret;
+		this.wsURL = param.wsURL;
+		this.timeout = param.timeout ?? 5e3;
+		this.reconnectDelay = param.reconnectDelay ?? 5e3;
+		this.compression = param.compression ?? true;
+		this.agent = param.agent ?? false;
+		this.mode = param.mode ?? "single";
+		this.poolSize = param.poolSize ?? 1;
+		this.privateKey = param.privateKey;
+		this.privateKeyPassphrase = param.privateKeyPassphrase;
+		this.timeUnit = param.timeUnit;
+		this.autoSessionReLogon = param.autoSessionReLogon ?? true;
+	}
 };
 var ConfigurationWebsocketStreams = class {
-  constructor(param = {}) {
-    this.wsURL = param.wsURL;
-    this.reconnectDelay = param.reconnectDelay ?? 5e3;
-    this.compression = param.compression ?? true;
-    this.agent = param.agent ?? false;
-    this.mode = param.mode ?? "single";
-    this.poolSize = param.poolSize ?? 1;
-    this.timeUnit = param.timeUnit;
-  }
+	constructor(param = {}) {
+		this.wsURL = param.wsURL;
+		this.reconnectDelay = param.reconnectDelay ?? 5e3;
+		this.compression = param.compression ?? true;
+		this.agent = param.agent ?? false;
+		this.mode = param.mode ?? "single";
+		this.poolSize = param.poolSize ?? 1;
+		this.timeUnit = param.timeUnit;
+	}
 };
 
-// src/constants.ts
-var TimeUnit = {
-  MILLISECOND: "MILLISECOND",
-  millisecond: "millisecond",
-  MICROSECOND: "MICROSECOND",
-  microsecond: "microsecond"
+//#endregion
+//#region src/constants.ts
+const TimeUnit = {
+	MILLISECOND: "MILLISECOND",
+	millisecond: "millisecond",
+	MICROSECOND: "MICROSECOND",
+	microsecond: "microsecond"
 };
-var ALGO_REST_API_PROD_URL = "https://api.binance.com";
-var C2C_REST_API_PROD_URL = "https://api.binance.com";
-var CONVERT_REST_API_PROD_URL = "https://api.binance.com";
-var COPY_TRADING_REST_API_PROD_URL = "https://api.binance.com";
-var CRYPTO_LOAN_REST_API_PROD_URL = "https://api.binance.com";
-var DERIVATIVES_TRADING_COIN_FUTURES_REST_API_PROD_URL = "https://dapi.binance.com";
-var DERIVATIVES_TRADING_COIN_FUTURES_REST_API_TESTNET_URL = "https://testnet.binancefuture.com";
-var DERIVATIVES_TRADING_COIN_FUTURES_WS_API_PROD_URL = "wss://ws-dapi.binance.com/ws-dapi/v1";
-var DERIVATIVES_TRADING_COIN_FUTURES_WS_API_TESTNET_URL = "wss://testnet.binancefuture.com/ws-dapi/v1";
-var DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_PROD_URL = "wss://dstream.binance.com";
-var DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_TESTNET_URL = "wss://dstream.binancefuture.com";
-var DERIVATIVES_TRADING_USDS_FUTURES_REST_API_PROD_URL = "https://fapi.binance.com";
-var DERIVATIVES_TRADING_USDS_FUTURES_REST_API_TESTNET_URL = "https://testnet.binancefuture.com";
-var DERIVATIVES_TRADING_USDS_FUTURES_WS_API_PROD_URL = "wss://ws-fapi.binance.com/ws-fapi/v1";
-var DERIVATIVES_TRADING_USDS_FUTURES_WS_API_TESTNET_URL = "wss://testnet.binancefuture.com/ws-fapi/v1";
-var DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_PROD_URL = "wss://fstream.binance.com";
-var DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_TESTNET_URL = "wss://stream.binancefuture.com";
-var DERIVATIVES_TRADING_OPTIONS_REST_API_PROD_URL = "https://eapi.binance.com";
-var DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_PROD_URL = "wss://nbstream.binance.com/eoptions";
-var DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_PROD_URL = "https://papi.binance.com";
-var DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_TESTNET_URL = "https://testnet.binancefuture.com";
-var DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_PROD_URL = "wss://fstream.binance.com/pm";
-var DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_TESTNET_URL = "wss://fstream.binancefuture.com/pm";
-var DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_REST_API_PROD_URL = "https://api.binance.com";
-var DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_WS_STREAMS_PROD_URL = "wss://fstream.binance.com/pm-classic";
-var DUAL_INVESTMENT_REST_API_PROD_URL = "https://api.binance.com";
-var FIAT_REST_API_PROD_URL = "https://api.binance.com";
-var GIFT_CARD_REST_API_PROD_URL = "https://api.binance.com";
-var MARGIN_TRADING_REST_API_PROD_URL = "https://api.binance.com";
-var MARGIN_TRADING_WS_STREAMS_PROD_URL = "wss://stream.binance.com:9443";
-var MARGIN_TRADING_RISK_WS_STREAMS_PROD_URL = "wss://margin-stream.binance.com";
-var MINING_REST_API_PROD_URL = "https://api.binance.com";
-var NFT_REST_API_PROD_URL = "https://api.binance.com";
-var PAY_REST_API_PROD_URL = "https://api.binance.com";
-var REBATE_REST_API_PROD_URL = "https://api.binance.com";
-var SIMPLE_EARN_REST_API_PROD_URL = "https://api.binance.com";
-var SPOT_REST_API_PROD_URL = "https://api.binance.com";
-var SPOT_REST_API_TESTNET_URL = "https://testnet.binance.vision";
-var SPOT_WS_API_PROD_URL = "wss://ws-api.binance.com:443/ws-api/v3";
-var SPOT_WS_API_TESTNET_URL = "wss://ws-api.testnet.binance.vision/ws-api/v3";
-var SPOT_WS_STREAMS_PROD_URL = "wss://stream.binance.com:9443";
-var SPOT_WS_STREAMS_TESTNET_URL = "wss://stream.testnet.binance.vision";
-var SPOT_REST_API_MARKET_URL = "https://data-api.binance.vision";
-var SPOT_WS_STREAMS_MARKET_URL = "wss://data-stream.binance.vision";
-var STAKING_REST_API_PROD_URL = "https://api.binance.com";
-var SUB_ACCOUNT_REST_API_PROD_URL = "https://api.binance.com";
-var VIP_LOAN_REST_API_PROD_URL = "https://api.binance.com";
-var WALLET_REST_API_PROD_URL = "https://api.binance.com";
+const ALGO_REST_API_PROD_URL = "https://api.binance.com";
+const C2C_REST_API_PROD_URL = "https://api.binance.com";
+const CONVERT_REST_API_PROD_URL = "https://api.binance.com";
+const COPY_TRADING_REST_API_PROD_URL = "https://api.binance.com";
+const CRYPTO_LOAN_REST_API_PROD_URL = "https://api.binance.com";
+const DERIVATIVES_TRADING_COIN_FUTURES_REST_API_PROD_URL = "https://dapi.binance.com";
+const DERIVATIVES_TRADING_COIN_FUTURES_REST_API_TESTNET_URL = "https://testnet.binancefuture.com";
+const DERIVATIVES_TRADING_COIN_FUTURES_WS_API_PROD_URL = "wss://ws-dapi.binance.com/ws-dapi/v1";
+const DERIVATIVES_TRADING_COIN_FUTURES_WS_API_TESTNET_URL = "wss://testnet.binancefuture.com/ws-dapi/v1";
+const DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_PROD_URL = "wss://dstream.binance.com";
+const DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_TESTNET_URL = "wss://dstream.binancefuture.com";
+const DERIVATIVES_TRADING_USDS_FUTURES_REST_API_PROD_URL = "https://fapi.binance.com";
+const DERIVATIVES_TRADING_USDS_FUTURES_REST_API_TESTNET_URL = "https://testnet.binancefuture.com";
+const DERIVATIVES_TRADING_USDS_FUTURES_WS_API_PROD_URL = "wss://ws-fapi.binance.com/ws-fapi/v1";
+const DERIVATIVES_TRADING_USDS_FUTURES_WS_API_TESTNET_URL = "wss://testnet.binancefuture.com/ws-fapi/v1";
+const DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_PROD_URL = "wss://fstream.binance.com";
+const DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_TESTNET_URL = "wss://stream.binancefuture.com";
+const DERIVATIVES_TRADING_OPTIONS_REST_API_PROD_URL = "https://eapi.binance.com";
+const DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_PROD_URL = "wss://nbstream.binance.com/eoptions";
+const DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_PROD_URL = "https://papi.binance.com";
+const DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_TESTNET_URL = "https://testnet.binancefuture.com";
+const DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_PROD_URL = "wss://fstream.binance.com/pm";
+const DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_TESTNET_URL = "wss://fstream.binancefuture.com/pm";
+const DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_REST_API_PROD_URL = "https://api.binance.com";
+const DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_WS_STREAMS_PROD_URL = "wss://fstream.binance.com/pm-classic";
+const DUAL_INVESTMENT_REST_API_PROD_URL = "https://api.binance.com";
+const FIAT_REST_API_PROD_URL = "https://api.binance.com";
+const GIFT_CARD_REST_API_PROD_URL = "https://api.binance.com";
+const MARGIN_TRADING_REST_API_PROD_URL = "https://api.binance.com";
+const MARGIN_TRADING_WS_STREAMS_PROD_URL = "wss://stream.binance.com:9443";
+const MARGIN_TRADING_RISK_WS_STREAMS_PROD_URL = "wss://margin-stream.binance.com";
+const MINING_REST_API_PROD_URL = "https://api.binance.com";
+const NFT_REST_API_PROD_URL = "https://api.binance.com";
+const PAY_REST_API_PROD_URL = "https://api.binance.com";
+const REBATE_REST_API_PROD_URL = "https://api.binance.com";
+const SIMPLE_EARN_REST_API_PROD_URL = "https://api.binance.com";
+const SPOT_REST_API_PROD_URL = "https://api.binance.com";
+const SPOT_REST_API_TESTNET_URL = "https://testnet.binance.vision";
+const SPOT_WS_API_PROD_URL = "wss://ws-api.binance.com:443/ws-api/v3";
+const SPOT_WS_API_TESTNET_URL = "wss://ws-api.testnet.binance.vision/ws-api/v3";
+const SPOT_WS_STREAMS_PROD_URL = "wss://stream.binance.com:9443";
+const SPOT_WS_STREAMS_TESTNET_URL = "wss://stream.testnet.binance.vision";
+const SPOT_REST_API_MARKET_URL = "https://data-api.binance.vision";
+const SPOT_WS_STREAMS_MARKET_URL = "wss://data-stream.binance.vision";
+const STAKING_REST_API_PROD_URL = "https://api.binance.com";
+const SUB_ACCOUNT_REST_API_PROD_URL = "https://api.binance.com";
+const VIP_LOAN_REST_API_PROD_URL = "https://api.binance.com";
+const WALLET_REST_API_PROD_URL = "https://api.binance.com";
 
-// src/errors.ts
-var ConnectorClientError = class _ConnectorClientError extends Error {
-  constructor(msg) {
-    super(msg || "An unexpected error occurred.");
-    Object.setPrototypeOf(this, _ConnectorClientError.prototype);
-    this.name = "ConnectorClientError";
-  }
+//#endregion
+//#region src/errors.ts
+/**
+* Represents an error that occurred in the Connector client.
+* @param msg - An optional error message.
+*/
+var ConnectorClientError = class ConnectorClientError extends Error {
+	constructor(msg) {
+		super(msg || "An unexpected error occurred.");
+		Object.setPrototypeOf(this, ConnectorClientError.prototype);
+		this.name = "ConnectorClientError";
+	}
 };
-var RequiredError = class _RequiredError extends Error {
-  constructor(field, msg) {
-    super(msg || `Required parameter ${field} was null or undefined.`);
-    this.field = field;
-    Object.setPrototypeOf(this, _RequiredError.prototype);
-    this.name = "RequiredError";
-  }
+/**
+* Represents an error that occurs when a required parameter is missing or undefined.
+* @param field - The name of the missing parameter.
+* @param msg - An optional error message.
+*/
+var RequiredError = class RequiredError extends Error {
+	constructor(field, msg) {
+		super(msg || `Required parameter ${field} was null or undefined.`);
+		this.field = field;
+		Object.setPrototypeOf(this, RequiredError.prototype);
+		this.name = "RequiredError";
+	}
 };
-var UnauthorizedError = class _UnauthorizedError extends Error {
-  constructor(msg) {
-    super(msg || "Unauthorized access. Authentication required.");
-    Object.setPrototypeOf(this, _UnauthorizedError.prototype);
-    this.name = "UnauthorizedError";
-  }
+/**
+* Represents an error that occurs when a client is unauthorized to access a resource.
+* @param msg - An optional error message.
+*/
+var UnauthorizedError = class UnauthorizedError extends Error {
+	constructor(msg) {
+		super(msg || "Unauthorized access. Authentication required.");
+		Object.setPrototypeOf(this, UnauthorizedError.prototype);
+		this.name = "UnauthorizedError";
+	}
 };
-var ForbiddenError = class _ForbiddenError extends Error {
-  constructor(msg) {
-    super(msg || "Access to the requested resource is forbidden.");
-    Object.setPrototypeOf(this, _ForbiddenError.prototype);
-    this.name = "ForbiddenError";
-  }
+/**
+* Represents an error that occurs when a resource is forbidden to the client.
+* @param msg - An optional error message.
+*/
+var ForbiddenError = class ForbiddenError extends Error {
+	constructor(msg) {
+		super(msg || "Access to the requested resource is forbidden.");
+		Object.setPrototypeOf(this, ForbiddenError.prototype);
+		this.name = "ForbiddenError";
+	}
 };
-var TooManyRequestsError = class _TooManyRequestsError extends Error {
-  constructor(msg) {
-    super(msg || "Too many requests. You are being rate-limited.");
-    Object.setPrototypeOf(this, _TooManyRequestsError.prototype);
-    this.name = "TooManyRequestsError";
-  }
+/**
+* Represents an error that occurs when client is doing too many requests.
+* @param msg - An optional error message.
+*/
+var TooManyRequestsError = class TooManyRequestsError extends Error {
+	constructor(msg) {
+		super(msg || "Too many requests. You are being rate-limited.");
+		Object.setPrototypeOf(this, TooManyRequestsError.prototype);
+		this.name = "TooManyRequestsError";
+	}
 };
-var RateLimitBanError = class _RateLimitBanError extends Error {
-  constructor(msg) {
-    super(msg || "The IP address has been banned for exceeding rate limits.");
-    Object.setPrototypeOf(this, _RateLimitBanError.prototype);
-    this.name = "RateLimitBanError";
-  }
+/**
+* Represents an error that occurs when client's IP has been banned.
+* @param msg - An optional error message.
+*/
+var RateLimitBanError = class RateLimitBanError extends Error {
+	constructor(msg) {
+		super(msg || "The IP address has been banned for exceeding rate limits.");
+		Object.setPrototypeOf(this, RateLimitBanError.prototype);
+		this.name = "RateLimitBanError";
+	}
 };
-var ServerError = class _ServerError extends Error {
-  constructor(msg, statusCode) {
-    super(msg || "An internal server error occurred.");
-    this.statusCode = statusCode;
-    Object.setPrototypeOf(this, _ServerError.prototype);
-    this.name = "ServerError";
-  }
+/**
+* Represents an error that occurs when there is an internal server error.
+* @param msg - An optional error message.
+* @param statusCode - An optional HTTP status code associated with the error.
+*/
+var ServerError = class ServerError extends Error {
+	constructor(msg, statusCode) {
+		super(msg || "An internal server error occurred.");
+		this.statusCode = statusCode;
+		Object.setPrototypeOf(this, ServerError.prototype);
+		this.name = "ServerError";
+	}
 };
-var NetworkError = class _NetworkError extends Error {
-  constructor(msg) {
-    super(msg || "A network error occurred.");
-    Object.setPrototypeOf(this, _NetworkError.prototype);
-    this.name = "NetworkError";
-  }
+/**
+* Represents an error that occurs when a network error occurs.
+* @param msg - An optional error message.
+*/
+var NetworkError = class NetworkError extends Error {
+	constructor(msg) {
+		super(msg || "A network error occurred.");
+		Object.setPrototypeOf(this, NetworkError.prototype);
+		this.name = "NetworkError";
+	}
 };
-var NotFoundError = class _NotFoundError extends Error {
-  constructor(msg) {
-    super(msg || "The requested resource was not found.");
-    Object.setPrototypeOf(this, _NotFoundError.prototype);
-    this.name = "NotFoundError";
-  }
+/**
+* Represents an error that occurs when the requested resource was not found.
+* @param msg - An optional error message.
+*/
+var NotFoundError = class NotFoundError extends Error {
+	constructor(msg) {
+		super(msg || "The requested resource was not found.");
+		Object.setPrototypeOf(this, NotFoundError.prototype);
+		this.name = "NotFoundError";
+	}
 };
-var BadRequestError = class _BadRequestError extends Error {
-  constructor(msg) {
-    super(msg || "The request was invalid or cannot be otherwise served.");
-    Object.setPrototypeOf(this, _BadRequestError.prototype);
-    this.name = "BadRequestError";
-  }
+/**
+* Represents an error that occurs when a request is invalid or cannot be otherwise served.
+* @param msg - An optional error message.
+*/
+var BadRequestError = class BadRequestError extends Error {
+	constructor(msg) {
+		super(msg || "The request was invalid or cannot be otherwise served.");
+		Object.setPrototypeOf(this, BadRequestError.prototype);
+		this.name = "BadRequestError";
+	}
 };
 
-// src/logger.ts
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2["NONE"] = "";
-  LogLevel2["DEBUG"] = "debug";
-  LogLevel2["INFO"] = "info";
-  LogLevel2["WARN"] = "warn";
-  LogLevel2["ERROR"] = "error";
-  return LogLevel2;
-})(LogLevel || {});
-var Logger = class _Logger {
-  constructor() {
-    this.minLogLevel = "info" /* INFO */;
-    this.levelsOrder = [
-      "" /* NONE */,
-      "debug" /* DEBUG */,
-      "info" /* INFO */,
-      "warn" /* WARN */,
-      "error" /* ERROR */
-    ];
-    const envLevel = process.env.LOG_LEVEL?.toLowerCase();
-    this.minLogLevel = envLevel && this.isValidLogLevel(envLevel) ? envLevel : "info" /* INFO */;
-  }
-  static getInstance() {
-    if (!_Logger.instance) _Logger.instance = new _Logger();
-    return _Logger.instance;
-  }
-  setMinLogLevel(level) {
-    if (!this.isValidLogLevel(level)) throw new Error(`Invalid log level: ${level}`);
-    this.minLogLevel = level;
-  }
-  isValidLogLevel(level) {
-    return this.levelsOrder.includes(level);
-  }
-  log(level, ...message) {
-    if (level === "" /* NONE */ || !this.allowLevelLog(level)) return;
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    console[level](`[${timestamp}] [${level.toLowerCase()}]`, ...message);
-  }
-  allowLevelLog(level) {
-    if (!this.isValidLogLevel(level)) throw new Error(`Invalid log level: ${level}`);
-    const currentLevelIndex = this.levelsOrder.indexOf(level);
-    const minLevelIndex = this.levelsOrder.indexOf(this.minLogLevel);
-    return currentLevelIndex >= minLevelIndex;
-  }
-  debug(...message) {
-    this.log("debug" /* DEBUG */, ...message);
-  }
-  info(...message) {
-    this.log("info" /* INFO */, ...message);
-  }
-  warn(...message) {
-    this.log("warn" /* WARN */, ...message);
-  }
-  error(...message) {
-    this.log("error" /* ERROR */, ...message);
-  }
+//#endregion
+//#region src/logger.ts
+let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	LogLevel$1["NONE"] = "";
+	LogLevel$1["DEBUG"] = "debug";
+	LogLevel$1["INFO"] = "info";
+	LogLevel$1["WARN"] = "warn";
+	LogLevel$1["ERROR"] = "error";
+	return LogLevel$1;
+}({});
+var Logger = class Logger {
+	constructor() {
+		this.minLogLevel = LogLevel.INFO;
+		this.levelsOrder = [
+			LogLevel.NONE,
+			LogLevel.DEBUG,
+			LogLevel.INFO,
+			LogLevel.WARN,
+			LogLevel.ERROR
+		];
+		const envLevel = process.env.LOG_LEVEL?.toLowerCase();
+		this.minLogLevel = envLevel && this.isValidLogLevel(envLevel) ? envLevel : LogLevel.INFO;
+	}
+	static getInstance() {
+		if (!Logger.instance) Logger.instance = new Logger();
+		return Logger.instance;
+	}
+	setMinLogLevel(level) {
+		if (!this.isValidLogLevel(level)) throw new Error(`Invalid log level: ${level}`);
+		this.minLogLevel = level;
+	}
+	isValidLogLevel(level) {
+		return this.levelsOrder.includes(level);
+	}
+	log(level, ...message) {
+		if (level === LogLevel.NONE || !this.allowLevelLog(level)) return;
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		console[level](`[${timestamp}] [${level.toLowerCase()}]`, ...message);
+	}
+	allowLevelLog(level) {
+		if (!this.isValidLogLevel(level)) throw new Error(`Invalid log level: ${level}`);
+		return this.levelsOrder.indexOf(level) >= this.levelsOrder.indexOf(this.minLogLevel);
+	}
+	debug(...message) {
+		this.log(LogLevel.DEBUG, ...message);
+	}
+	info(...message) {
+		this.log(LogLevel.INFO, ...message);
+	}
+	warn(...message) {
+		this.log(LogLevel.WARN, ...message);
+	}
+	error(...message) {
+		this.log(LogLevel.ERROR, ...message);
+	}
 };
 
-// src/websocket.ts
-var import_events = require("events");
-var import_ws = __toESM(require("ws"));
-var import_json_with_bigint2 = require("json-with-bigint");
+//#endregion
+//#region src/websocket.ts
 var WebsocketEventEmitter = class {
-  constructor() {
-    this.eventEmitter = new import_events.EventEmitter();
-  }
-  /* eslint-disable @typescript-eslint/no-explicit-any */
-  on(event, listener) {
-    this.eventEmitter.on(event, listener);
-  }
-  /* eslint-disable @typescript-eslint/no-explicit-any */
-  off(event, listener) {
-    this.eventEmitter.off(event, listener);
-  }
-  /* eslint-disable @typescript-eslint/no-explicit-any */
-  emit(event, ...args) {
-    this.eventEmitter.emit(event, ...args);
-  }
+	constructor() {
+		this.eventEmitter = new events.EventEmitter();
+	}
+	on(event, listener) {
+		this.eventEmitter.on(event, listener);
+	}
+	off(event, listener) {
+		this.eventEmitter.off(event, listener);
+	}
+	emit(event, ...args) {
+		this.eventEmitter.emit(event, ...args);
+	}
 };
-var WebsocketCommon = class _WebsocketCommon extends WebsocketEventEmitter {
-  constructor(configuration, connectionPool = []) {
-    super();
-    this.configuration = configuration;
-    this.connectionQueue = [];
-    this.queueProcessing = false;
-    this.connectionTimers = /* @__PURE__ */ new Map();
-    this.roundRobinIndex = 0;
-    this.logger = Logger.getInstance();
-    this.connectionPool = connectionPool;
-    this.mode = this.configuration?.mode ?? "single";
-    this.poolSize = this.mode === "pool" && this.configuration?.poolSize ? this.configuration.poolSize : 1;
-    if (!connectionPool || connectionPool.length === 0) this.initializePool(this.poolSize);
-  }
-  static {
-    this.MAX_CONNECTION_DURATION = 23 * 60 * 60 * 1e3;
-  }
-  /**
-   * Initializes the WebSocket connection pool by creating a specified number of connection objects
-   * and adding them to the `connectionPool` array. Each connection object has the following properties:
-   * - `closeInitiated`: a boolean indicating whether the connection has been closed
-   * - `reconnectionPending`: a boolean indicating whether a reconnection is pending
-   * - `pendingRequests`: a Map that tracks pending requests for the connection
-   * @param size - The number of connection objects to create and add to the pool.
-   * @returns void
-   */
-  initializePool(size) {
-    for (let i = 0; i < size; i++) {
-      this.connectionPool.push({
-        id: randomString(),
-        closeInitiated: false,
-        reconnectionPending: false,
-        renewalPending: false,
-        pendingRequests: /* @__PURE__ */ new Map(),
-        pendingSubscriptions: []
-      });
-    }
-  }
-  /**
-   * Retrieves available WebSocket connections based on the connection mode and readiness.
-   * In 'single' mode, returns the first connection in the pool.
-   * In 'pool' mode, filters and returns connections that are ready for use.
-   * @param allowNonEstablishedWebsockets - Optional flag to include non-established WebSocket connections.
-   * @returns An array of available WebSocket connections.
-   */
-  getAvailableConnections(allowNonEstablishedWebsockets = false) {
-    if (this.mode === "single") return [this.connectionPool[0]];
-    const availableConnections = this.connectionPool.filter(
-      (connection) => this.isConnectionReady(connection, allowNonEstablishedWebsockets)
-    );
-    return availableConnections;
-  }
-  /**
-   * Gets a WebSocket connection from the pool or single connection.
-   * If the connection mode is 'single', it returns the first connection in the pool.
-   * If the connection mode is 'pool', it returns an available connection from the pool,
-   * using a round-robin selection strategy. If no available connections are found, it throws an error.
-   * @param allowNonEstablishedWebsockets - A boolean indicating whether to allow connections that are not established.
-   * @returns {WebsocketConnection} The selected WebSocket connection.
-   */
-  getConnection(allowNonEstablishedWebsockets = false) {
-    const availableConnections = this.getAvailableConnections(allowNonEstablishedWebsockets);
-    if (availableConnections.length === 0) {
-      throw new Error("No available Websocket connections are ready.");
-    }
-    const selectedConnection = availableConnections[this.roundRobinIndex % availableConnections.length];
-    this.roundRobinIndex = (this.roundRobinIndex + 1) % availableConnections.length;
-    return selectedConnection;
-  }
-  /**
-   * Checks if the provided WebSocket connection is ready for use.
-   * A connection is considered ready if it is open, has no pending reconnection, and has not been closed.
-   * @param connection - The WebSocket connection to check.
-   * @param allowNonEstablishedWebsockets - An optional flag to allow non-established WebSocket connections.
-   * @returns `true` if the connection is ready, `false` otherwise.
-   */
-  isConnectionReady(connection, allowNonEstablishedWebsockets = false) {
-    return (allowNonEstablishedWebsockets || connection.ws?.readyState === import_ws.default.OPEN) && !connection.reconnectionPending && !connection.closeInitiated;
-  }
-  /**
-   * Schedules a timer for a WebSocket connection and tracks it
-   * @param connection WebSocket client instance
-   * @param callback Function to execute when timer triggers
-   * @param delay Time in milliseconds before callback execution
-   * @param type Timer type ('timeout' or 'interval')
-   * @returns Timer handle
-   */
-  scheduleTimer(connection, callback, delay2, type = "timeout") {
-    let timers = this.connectionTimers.get(connection);
-    if (!timers) {
-      timers = /* @__PURE__ */ new Set();
-      this.connectionTimers.set(connection, timers);
-    }
-    const timerRecord = { type };
-    const wrappedTimeout = () => {
-      try {
-        callback();
-      } finally {
-        timers.delete(timerRecord);
-      }
-    };
-    let timer;
-    if (type === "timeout") timer = setTimeout(wrappedTimeout, delay2);
-    else timer = setInterval(callback, delay2);
-    timerRecord.timer = timer;
-    timers.add(timerRecord);
-    return timer;
-  }
-  /**
-   * Clears all timers associated with a WebSocket connection.
-   * @param connection - The WebSocket client instance to clear timers for.
-   * @returns void
-   */
-  clearTimers(connection) {
-    const timers = this.connectionTimers.get(connection);
-    if (timers) {
-      timers.forEach(({ timer, type }) => {
-        if (type === "timeout") clearTimeout(timer);
-        else if (type === "interval") clearInterval(timer);
-      });
-      this.connectionTimers.delete(connection);
-    }
-  }
-  /**
-   * Processes the connection queue, reconnecting or renewing connections as needed.
-   * This method is responsible for iterating through the connection queue and initiating
-   * the reconnection or renewal process for each connection in the queue. It throttles
-   * the queue processing to avoid overwhelming the server with too many connection
-   * requests at once.
-   * @param throttleRate - The time in milliseconds to wait between processing each
-   * connection in the queue.
-   * @returns A Promise that resolves when the queue has been fully processed.
-   */
-  async processQueue(throttleRate = 1e3) {
-    if (this.queueProcessing) return;
-    this.queueProcessing = true;
-    while (this.connectionQueue.length > 0) {
-      const { connection, url, isRenewal } = this.connectionQueue.shift();
-      this.initConnect(url, isRenewal, connection);
-      await delay(throttleRate);
-    }
-    this.queueProcessing = false;
-  }
-  /**
-   * Enqueues a reconnection or renewal for a WebSocket connection.
-   * This method adds the connection, URL, and renewal flag to the connection queue,
-   * and then calls the `processQueue` method to initiate the reconnection or renewal
-   * process.
-   * @param connection - The WebSocket connection to reconnect or renew.
-   * @param url - The URL to use for the reconnection or renewal.
-   * @param isRenewal - A flag indicating whether this is a renewal (true) or a reconnection (false).
-   */
-  enqueueReconnection(connection, url, isRenewal) {
-    this.connectionQueue.push({ connection, url, isRenewal });
-    this.processQueue();
-  }
-  /**
-   * Gracefully closes a WebSocket connection after pending requests complete.
-   * This method waits for any pending requests to complete before closing the connection.
-   * It sets up a timeout to force-close the connection after 30 seconds if the pending requests
-   * do not complete. Once all pending requests are completed, the connection is closed.
-   * @param connectionToClose - The WebSocket client instance to close.
-   * @param WebsocketConnectionToClose - The WebSocket connection to close.
-   * @param connection - The WebSocket connection to close.
-   * @returns Promise that resolves when the connection is closed.
-   */
-  async closeConnectionGracefully(WebsocketConnectionToClose, connection) {
-    if (!WebsocketConnectionToClose || !connection) return;
-    this.logger.debug(
-      `Waiting for pending requests to complete before disconnecting websocket on connection ${connection.id}.`
-    );
-    const closePromise = new Promise((resolve) => {
-      this.scheduleTimer(
-        WebsocketConnectionToClose,
-        () => {
-          this.logger.warn(
-            `Force-closing websocket connection after 30 seconds on connection ${connection.id}.`
-          );
-          resolve();
-        },
-        3e4
-      );
-      this.scheduleTimer(
-        WebsocketConnectionToClose,
-        () => {
-          if (connection.pendingRequests.size === 0) {
-            this.logger.debug(
-              `All pending requests completed, closing websocket connection on connection ${connection.id}.`
-            );
-            resolve();
-          }
-        },
-        1e3,
-        "interval"
-      );
-    });
-    await closePromise;
-    this.logger.info(`Closing Websocket connection on connection ${connection.id}.`);
-    WebsocketConnectionToClose.close();
-    this.cleanup(WebsocketConnectionToClose);
-  }
-  /**
-   * Attempts to re-establish a session for a WebSocket connection.
-   * If a session logon request exists and the connection is not already logged on,
-   * it sends an authentication request and updates the connection's logged-on status.
-   * @param connection - The WebSocket connection to re-authenticate.
-   * @private
-   */
-  async sessionReLogon(connection) {
-    const req = connection.sessionLogonReq;
-    if (req && !connection.isSessionLoggedOn) {
-      const data = buildWebsocketAPIMessage(
-        this.configuration,
-        req.method,
-        req.payload,
-        req.options
-      );
-      this.logger.debug(`Session re-logon on connection ${connection.id}`, data);
-      try {
-        await this.send(
-          JSON.stringify(data),
-          data.id,
-          true,
-          this.configuration.timeout,
-          connection
-        );
-        this.logger.debug(
-          `Session re-logon on connection ${connection.id} was successful.`
-        );
-        connection.isSessionLoggedOn = true;
-      } catch (err) {
-        this.logger.error(`Session re-logon on connection ${connection.id} failed:`, err);
-      }
-    }
-  }
-  /**
-   * Cleans up WebSocket connection resources.
-   * Removes all listeners and clears any associated timers for the provided WebSocket client.
-   * @param ws - The WebSocket client to clean up.
-   * @returns void
-   */
-  cleanup(ws) {
-    if (ws) {
-      ws.removeAllListeners();
-      this.clearTimers(ws);
-    }
-  }
-  /**
-   * Handles incoming WebSocket messages
-   * @param data Raw message data received
-   * @param connection Websocket connection
-   */
-  onMessage(data, connection) {
-    this.emit("message", data.toString(), connection);
-  }
-  /**
-   * Handles the opening of a WebSocket connection.
-   * @param url - The URL of the WebSocket server.
-   * @param targetConnection - The WebSocket connection being opened.
-   * @param oldWSConnection - The WebSocket client instance associated with the old connection.
-   */
-  onOpen(url, targetConnection, oldWSConnection) {
-    this.logger.info(
-      `Connected to the Websocket Server with id ${targetConnection.id}: ${url}`
-    );
-    if (targetConnection.renewalPending) {
-      targetConnection.renewalPending = false;
-      this.closeConnectionGracefully(oldWSConnection, targetConnection);
-    } else if (targetConnection.closeInitiated) {
-      this.closeConnectionGracefully(targetConnection.ws, targetConnection);
-    } else {
-      targetConnection.reconnectionPending = false;
-      this.emit("open", this);
-    }
-    this.sessionReLogon(targetConnection);
-  }
-  /**
-   * Returns the URL to use when reconnecting.
-   * Derived classes should override this to provide dynamic URLs.
-   * @param defaultURL The URL originally passed during the first connection.
-   * @param targetConnection The WebSocket connection being connected.
-   * @returns The URL to reconnect to.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  getReconnectURL(defaultURL, targetConnection) {
-    return defaultURL;
-  }
-  /**
-   * Connects all WebSocket connections in the pool
-   * @param url - The Websocket server URL.
-   * @returns A promise that resolves when all connections are established.
-   */
-  async connectPool(url) {
-    const connectPromises = this.connectionPool.map(
-      (connection) => new Promise((resolve, reject) => {
-        this.initConnect(url, false, connection);
-        connection.ws?.on("open", () => resolve());
-        connection.ws?.on("error", (err) => reject(err));
-        connection.ws?.on(
-          "close",
-          () => reject(new Error("Connection closed unexpectedly."))
-        );
-      })
-    );
-    await Promise.all(connectPromises);
-  }
-  /**
-   * Creates a new WebSocket client instance.
-   * @param url - The URL to connect to.
-   * @returns A new WebSocket client instance.
-   */
-  createWebSocket(url) {
-    const wsClientOptions = {
-      perMessageDeflate: this.configuration?.compression,
-      agent: this.configuration?.agent
-    };
-    if (this.configuration.userAgent)
-      wsClientOptions.headers = { "User-Agent": this.configuration.userAgent };
-    return new import_ws.default(url, wsClientOptions);
-  }
-  /**
-   * Initializes a WebSocket connection.
-   * @param url - The Websocket server URL.
-   * @param isRenewal - Whether this is a connection renewal.
-   * @param connection - An optional WebSocket connection to use.
-   * @returns The WebSocket connection.
-   */
-  initConnect(url, isRenewal = false, connection) {
-    const targetConnection = connection || this.getConnection();
-    if (targetConnection.renewalPending && isRenewal) {
-      this.logger.warn(
-        `Connection renewal with id ${targetConnection.id} is already in progress`
-      );
-      return;
-    }
-    if (targetConnection.ws && targetConnection.ws.readyState === import_ws.default.OPEN && !isRenewal) {
-      this.logger.warn(`Connection with id ${targetConnection.id} already exists`);
-      return;
-    }
-    const ws = this.createWebSocket(url);
-    this.logger.info(
-      `Establishing Websocket connection with id ${targetConnection.id} to: ${url}`
-    );
-    if (isRenewal) targetConnection.renewalPending = true;
-    else targetConnection.ws = ws;
-    targetConnection.isSessionLoggedOn = false;
-    this.scheduleTimer(
-      ws,
-      () => {
-        this.logger.info(`Renewing Websocket connection with id ${targetConnection.id}`);
-        targetConnection.isSessionLoggedOn = false;
-        this.enqueueReconnection(
-          targetConnection,
-          this.getReconnectURL(url, targetConnection),
-          true
-        );
-      },
-      _WebsocketCommon.MAX_CONNECTION_DURATION
-    );
-    ws.on("open", () => {
-      const oldWSConnection = targetConnection.ws;
-      if (targetConnection.renewalPending) targetConnection.ws = ws;
-      this.onOpen(url, targetConnection, oldWSConnection);
-    });
-    ws.on("message", (data) => {
-      this.onMessage(data.toString(), targetConnection);
-    });
-    ws.on("ping", () => {
-      this.logger.debug("Received PING from server");
-      this.emit("ping");
-      ws.pong();
-      this.logger.debug("Responded PONG to server's PING message");
-    });
-    ws.on("pong", () => {
-      this.logger.debug("Received PONG from server");
-      this.emit("pong");
-    });
-    ws.on("error", (err) => {
-      this.logger.error("Received error from server");
-      this.logger.error(err);
-      this.emit("error", err);
-    });
-    ws.on("close", (closeEventCode, reason) => {
-      this.emit("close", closeEventCode, reason);
-      if (!targetConnection.closeInitiated && !isRenewal) {
-        this.cleanup(ws);
-        this.logger.warn(
-          `Connection with id ${targetConnection.id} closed due to ${closeEventCode}: ${reason}`
-        );
-        this.scheduleTimer(
-          ws,
-          () => {
-            this.logger.info(
-              `Reconnecting conection with id ${targetConnection.id} to the server.`
-            );
-            targetConnection.isSessionLoggedOn = false;
-            targetConnection.reconnectionPending = true;
-            this.enqueueReconnection(
-              targetConnection,
-              this.getReconnectURL(url, targetConnection),
-              false
-            );
-          },
-          this.configuration?.reconnectDelay ?? 5e3
-        );
-      }
-    });
-    return targetConnection;
-  }
-  /**
-   * Checks if the WebSocket connection is currently open.
-   * @param connection - An optional WebSocket connection to check. If not provided, the entire connection pool is checked.
-   * @returns `true` if the connection is open, `false` otherwise.
-   */
-  isConnected(connection) {
-    const connectionPool = connection ? [connection] : this.connectionPool;
-    return connectionPool.some((connection2) => this.isConnectionReady(connection2));
-  }
-  /**
-   * Disconnects from the WebSocket server.
-   * If there is no active connection, a warning is logged.
-   * Otherwise, all connections in the connection pool are closed gracefully,
-   * and a message is logged indicating that the connection has been disconnected.
-   * @returns A Promise that resolves when all connections have been closed.
-   * @throws Error if the WebSocket client is not set.
-   */
-  async disconnect() {
-    if (!this.isConnected()) this.logger.warn("No connection to close.");
-    else {
-      this.connectionPool.forEach((connection) => {
-        connection.closeInitiated = true;
-        connection.isSessionLoggedOn = false;
-        connection.sessionLogonReq = void 0;
-      });
-      const disconnectPromises = this.connectionPool.map(
-        (connection) => this.closeConnectionGracefully(connection.ws, connection)
-      );
-      await Promise.all(disconnectPromises);
-      this.logger.info("Disconnected with Binance Websocket Server");
-    }
-  }
-  /**
-   * Sends a ping message to all connected Websocket servers in the pool.
-   * If no connections are ready, a warning is logged.
-   * For each active connection, the ping message is sent, and debug logs provide details.
-   * @throws Error if a Websocket client is not set for a connection.
-   */
-  pingServer() {
-    const connectedConnections = this.connectionPool.filter(
-      (connection) => this.isConnected(connection)
-    );
-    if (connectedConnections.length === 0) {
-      this.logger.warn("Ping only can be sent when connection is ready.");
-      return;
-    }
-    this.logger.debug("Sending PING to all connected Websocket servers.");
-    connectedConnections.forEach((connection) => {
-      if (connection.ws) {
-        connection.ws.ping();
-        this.logger.debug(`PING sent to connection with id ${connection.id}`);
-      } else {
-        this.logger.error("WebSocket Client not set for a connection.");
-      }
-    });
-  }
-  /**
-   * Sends a payload through the WebSocket connection.
-   * @param payload - Message to send.
-   * @param id - Optional request identifier.
-   * @param promiseBased - Whether to return a promise.
-   * @param timeout - Timeout duration in milliseconds.
-   * @param connection - The WebSocket connection to use.
-   * @returns A promise if `promiseBased` is true, void otherwise.
-   * @throws Error if not connected or WebSocket client is not set.
-   */
-  send(payload, id, promiseBased = true, timeout = 5e3, connection) {
-    if (!this.isConnected(connection)) {
-      const errorMsg = "Unable to send message \u2014 connection is not available.";
-      this.logger.warn(errorMsg);
-      if (promiseBased) return Promise.reject(new Error(errorMsg));
-      else throw new Error(errorMsg);
-    }
-    const connectionToUse = connection ?? this.getConnection();
-    if (!connectionToUse.ws) {
-      const errorMsg = "Websocket Client not set";
-      this.logger.error(errorMsg);
-      if (promiseBased) return Promise.reject(new Error(errorMsg));
-      else throw new Error(errorMsg);
-    }
-    connectionToUse.ws.send(payload);
-    if (promiseBased) {
-      return new Promise((resolve, reject) => {
-        if (!id) return reject(new Error("id is required for promise-based sending."));
-        const timeoutHandle = setTimeout(() => {
-          if (connectionToUse.pendingRequests.has(id)) {
-            connectionToUse.pendingRequests.delete(id);
-            reject(new Error(`Request timeout for id: ${id}`));
-          }
-        }, timeout);
-        connectionToUse.pendingRequests.set(id, {
-          resolve: (v) => {
-            clearTimeout(timeoutHandle);
-            resolve(v);
-          },
-          reject: (e) => {
-            clearTimeout(timeoutHandle);
-            reject(e);
-          }
-        });
-      });
-    }
-  }
+var WebsocketCommon = class WebsocketCommon extends WebsocketEventEmitter {
+	static {
+		this.MAX_CONNECTION_DURATION = 1380 * 60 * 1e3;
+	}
+	constructor(configuration, connectionPool = []) {
+		super();
+		this.configuration = configuration;
+		this.connectionQueue = [];
+		this.queueProcessing = false;
+		this.connectionTimers = /* @__PURE__ */ new Map();
+		this.roundRobinIndex = 0;
+		this.logger = Logger.getInstance();
+		this.connectionPool = connectionPool;
+		this.mode = this.configuration?.mode ?? "single";
+		this.poolSize = this.mode === "pool" && this.configuration?.poolSize ? this.configuration.poolSize : 1;
+		if (!connectionPool || connectionPool.length === 0) this.initializePool(this.poolSize);
+	}
+	/**
+	* Initializes the WebSocket connection pool by creating a specified number of connection objects
+	* and adding them to the `connectionPool` array. Each connection object has the following properties:
+	* - `closeInitiated`: a boolean indicating whether the connection has been closed
+	* - `reconnectionPending`: a boolean indicating whether a reconnection is pending
+	* - `pendingRequests`: a Map that tracks pending requests for the connection
+	* @param size - The number of connection objects to create and add to the pool.
+	* @returns void
+	*/
+	initializePool(size) {
+		for (let i = 0; i < size; i++) this.connectionPool.push({
+			id: randomString(),
+			closeInitiated: false,
+			reconnectionPending: false,
+			renewalPending: false,
+			pendingRequests: /* @__PURE__ */ new Map(),
+			pendingSubscriptions: []
+		});
+	}
+	/**
+	* Retrieves available WebSocket connections based on the connection mode and readiness.
+	* In 'single' mode, returns the first connection in the pool.
+	* In 'pool' mode, filters and returns connections that are ready for use.
+	* @param allowNonEstablishedWebsockets - Optional flag to include non-established WebSocket connections.
+	* @returns An array of available WebSocket connections.
+	*/
+	getAvailableConnections(allowNonEstablishedWebsockets = false) {
+		if (this.mode === "single") return [this.connectionPool[0]];
+		return this.connectionPool.filter((connection) => this.isConnectionReady(connection, allowNonEstablishedWebsockets));
+	}
+	/**
+	* Gets a WebSocket connection from the pool or single connection.
+	* If the connection mode is 'single', it returns the first connection in the pool.
+	* If the connection mode is 'pool', it returns an available connection from the pool,
+	* using a round-robin selection strategy. If no available connections are found, it throws an error.
+	* @param allowNonEstablishedWebsockets - A boolean indicating whether to allow connections that are not established.
+	* @returns {WebsocketConnection} The selected WebSocket connection.
+	*/
+	getConnection(allowNonEstablishedWebsockets = false) {
+		const availableConnections = this.getAvailableConnections(allowNonEstablishedWebsockets);
+		if (availableConnections.length === 0) throw new Error("No available Websocket connections are ready.");
+		const selectedConnection = availableConnections[this.roundRobinIndex % availableConnections.length];
+		this.roundRobinIndex = (this.roundRobinIndex + 1) % availableConnections.length;
+		return selectedConnection;
+	}
+	/**
+	* Checks if the provided WebSocket connection is ready for use.
+	* A connection is considered ready if it is open, has no pending reconnection, and has not been closed.
+	* @param connection - The WebSocket connection to check.
+	* @param allowNonEstablishedWebsockets - An optional flag to allow non-established WebSocket connections.
+	* @returns `true` if the connection is ready, `false` otherwise.
+	*/
+	isConnectionReady(connection, allowNonEstablishedWebsockets = false) {
+		return (allowNonEstablishedWebsockets || connection.ws?.readyState === ws.default.OPEN) && !connection.reconnectionPending && !connection.closeInitiated;
+	}
+	/**
+	* Schedules a timer for a WebSocket connection and tracks it
+	* @param connection WebSocket client instance
+	* @param callback Function to execute when timer triggers
+	* @param delay Time in milliseconds before callback execution
+	* @param type Timer type ('timeout' or 'interval')
+	* @returns Timer handle
+	*/
+	scheduleTimer(connection, callback, delay$1, type = "timeout") {
+		let timers = this.connectionTimers.get(connection);
+		if (!timers) {
+			timers = /* @__PURE__ */ new Set();
+			this.connectionTimers.set(connection, timers);
+		}
+		const timerRecord = { type };
+		const wrappedTimeout = () => {
+			try {
+				callback();
+			} finally {
+				timers.delete(timerRecord);
+			}
+		};
+		let timer;
+		if (type === "timeout") timer = setTimeout(wrappedTimeout, delay$1);
+		else timer = setInterval(callback, delay$1);
+		timerRecord.timer = timer;
+		timers.add(timerRecord);
+		return timer;
+	}
+	/**
+	* Clears all timers associated with a WebSocket connection.
+	* @param connection - The WebSocket client instance to clear timers for.
+	* @returns void
+	*/
+	clearTimers(connection) {
+		const timers = this.connectionTimers.get(connection);
+		if (timers) {
+			timers.forEach(({ timer, type }) => {
+				if (type === "timeout") clearTimeout(timer);
+				else if (type === "interval") clearInterval(timer);
+			});
+			this.connectionTimers.delete(connection);
+		}
+	}
+	/**
+	* Processes the connection queue, reconnecting or renewing connections as needed.
+	* This method is responsible for iterating through the connection queue and initiating
+	* the reconnection or renewal process for each connection in the queue. It throttles
+	* the queue processing to avoid overwhelming the server with too many connection
+	* requests at once.
+	* @param throttleRate - The time in milliseconds to wait between processing each
+	* connection in the queue.
+	* @returns A Promise that resolves when the queue has been fully processed.
+	*/
+	async processQueue(throttleRate = 1e3) {
+		if (this.queueProcessing) return;
+		this.queueProcessing = true;
+		while (this.connectionQueue.length > 0) {
+			const { connection, url, isRenewal } = this.connectionQueue.shift();
+			this.initConnect(url, isRenewal, connection);
+			await delay(throttleRate);
+		}
+		this.queueProcessing = false;
+	}
+	/**
+	* Enqueues a reconnection or renewal for a WebSocket connection.
+	* This method adds the connection, URL, and renewal flag to the connection queue,
+	* and then calls the `processQueue` method to initiate the reconnection or renewal
+	* process.
+	* @param connection - The WebSocket connection to reconnect or renew.
+	* @param url - The URL to use for the reconnection or renewal.
+	* @param isRenewal - A flag indicating whether this is a renewal (true) or a reconnection (false).
+	*/
+	enqueueReconnection(connection, url, isRenewal) {
+		this.connectionQueue.push({
+			connection,
+			url,
+			isRenewal
+		});
+		this.processQueue();
+	}
+	/**
+	* Gracefully closes a WebSocket connection after pending requests complete.
+	* This method waits for any pending requests to complete before closing the connection.
+	* It sets up a timeout to force-close the connection after 30 seconds if the pending requests
+	* do not complete. Once all pending requests are completed, the connection is closed.
+	* @param connectionToClose - The WebSocket client instance to close.
+	* @param WebsocketConnectionToClose - The WebSocket connection to close.
+	* @param connection - The WebSocket connection to close.
+	* @returns Promise that resolves when the connection is closed.
+	*/
+	async closeConnectionGracefully(WebsocketConnectionToClose, connection) {
+		if (!WebsocketConnectionToClose || !connection) return;
+		this.logger.debug(`Waiting for pending requests to complete before disconnecting websocket on connection ${connection.id}.`);
+		await new Promise((resolve) => {
+			this.scheduleTimer(WebsocketConnectionToClose, () => {
+				this.logger.warn(`Force-closing websocket connection after 30 seconds on connection ${connection.id}.`);
+				resolve();
+			}, 3e4);
+			this.scheduleTimer(WebsocketConnectionToClose, () => {
+				if (connection.pendingRequests.size === 0) {
+					this.logger.debug(`All pending requests completed, closing websocket connection on connection ${connection.id}.`);
+					resolve();
+				}
+			}, 1e3, "interval");
+		});
+		this.logger.info(`Closing Websocket connection on connection ${connection.id}.`);
+		WebsocketConnectionToClose.close();
+		this.cleanup(WebsocketConnectionToClose);
+	}
+	/**
+	* Attempts to re-establish a session for a WebSocket connection.
+	* If a session logon request exists and the connection is not already logged on,
+	* it sends an authentication request and updates the connection's logged-on status.
+	* @param connection - The WebSocket connection to re-authenticate.
+	* @private
+	*/
+	async sessionReLogon(connection) {
+		const req = connection.sessionLogonReq;
+		if (req && !connection.isSessionLoggedOn) {
+			const data = buildWebsocketAPIMessage(this.configuration, req.method, req.payload, req.options);
+			this.logger.debug(`Session re-logon on connection ${connection.id}`, data);
+			try {
+				await this.send(JSON.stringify(data), data.id, true, this.configuration.timeout, connection);
+				this.logger.debug(`Session re-logon on connection ${connection.id} was successful.`);
+				connection.isSessionLoggedOn = true;
+			} catch (err) {
+				this.logger.error(`Session re-logon on connection ${connection.id} failed:`, err);
+			}
+		}
+	}
+	/**
+	* Cleans up WebSocket connection resources.
+	* Removes all listeners and clears any associated timers for the provided WebSocket client.
+	* @param ws - The WebSocket client to clean up.
+	* @returns void
+	*/
+	cleanup(ws$1) {
+		if (ws$1) {
+			ws$1.removeAllListeners();
+			this.clearTimers(ws$1);
+		}
+	}
+	/**
+	* Handles incoming WebSocket messages
+	* @param data Raw message data received
+	* @param connection Websocket connection
+	*/
+	onMessage(data, connection) {
+		this.emit("message", data.toString(), connection);
+	}
+	/**
+	* Handles the opening of a WebSocket connection.
+	* @param url - The URL of the WebSocket server.
+	* @param targetConnection - The WebSocket connection being opened.
+	* @param oldWSConnection - The WebSocket client instance associated with the old connection.
+	*/
+	onOpen(url, targetConnection, oldWSConnection) {
+		this.logger.info(`Connected to the Websocket Server with id ${targetConnection.id}: ${url}`);
+		if (targetConnection.renewalPending) {
+			targetConnection.renewalPending = false;
+			this.closeConnectionGracefully(oldWSConnection, targetConnection);
+		} else if (targetConnection.closeInitiated) this.closeConnectionGracefully(targetConnection.ws, targetConnection);
+		else {
+			targetConnection.reconnectionPending = false;
+			this.emit("open", this);
+		}
+		this.sessionReLogon(targetConnection);
+	}
+	/**
+	* Returns the URL to use when reconnecting.
+	* Derived classes should override this to provide dynamic URLs.
+	* @param defaultURL The URL originally passed during the first connection.
+	* @param targetConnection The WebSocket connection being connected.
+	* @returns The URL to reconnect to.
+	*/
+	getReconnectURL(defaultURL, targetConnection) {
+		return defaultURL;
+	}
+	/**
+	* Connects all WebSocket connections in the pool
+	* @param url - The Websocket server URL.
+	* @returns A promise that resolves when all connections are established.
+	*/
+	async connectPool(url) {
+		const connectPromises = this.connectionPool.map((connection) => new Promise((resolve, reject) => {
+			this.initConnect(url, false, connection);
+			connection.ws?.on("open", () => resolve());
+			connection.ws?.on("error", (err) => reject(err));
+			connection.ws?.on("close", () => reject(/* @__PURE__ */ new Error("Connection closed unexpectedly.")));
+		}));
+		await Promise.all(connectPromises);
+	}
+	/**
+	* Creates a new WebSocket client instance.
+	* @param url - The URL to connect to.
+	* @returns A new WebSocket client instance.
+	*/
+	createWebSocket(url) {
+		const wsClientOptions = {
+			perMessageDeflate: this.configuration?.compression,
+			agent: this.configuration?.agent
+		};
+		if (this.configuration.userAgent) wsClientOptions.headers = { "User-Agent": this.configuration.userAgent };
+		return new ws.default(url, wsClientOptions);
+	}
+	/**
+	* Initializes a WebSocket connection.
+	* @param url - The Websocket server URL.
+	* @param isRenewal - Whether this is a connection renewal.
+	* @param connection - An optional WebSocket connection to use.
+	* @returns The WebSocket connection.
+	*/
+	initConnect(url, isRenewal = false, connection) {
+		const targetConnection = connection || this.getConnection();
+		if (targetConnection.renewalPending && isRenewal) {
+			this.logger.warn(`Connection renewal with id ${targetConnection.id} is already in progress`);
+			return;
+		}
+		if (targetConnection.ws && targetConnection.ws.readyState === ws.default.OPEN && !isRenewal) {
+			this.logger.warn(`Connection with id ${targetConnection.id} already exists`);
+			return;
+		}
+		const ws$1 = this.createWebSocket(url);
+		this.logger.info(`Establishing Websocket connection with id ${targetConnection.id} to: ${url}`);
+		if (isRenewal) targetConnection.renewalPending = true;
+		else targetConnection.ws = ws$1;
+		targetConnection.isSessionLoggedOn = false;
+		this.scheduleTimer(ws$1, () => {
+			this.logger.info(`Renewing Websocket connection with id ${targetConnection.id}`);
+			targetConnection.isSessionLoggedOn = false;
+			this.enqueueReconnection(targetConnection, this.getReconnectURL(url, targetConnection), true);
+		}, WebsocketCommon.MAX_CONNECTION_DURATION);
+		ws$1.on("open", () => {
+			const oldWSConnection = targetConnection.ws;
+			if (targetConnection.renewalPending) targetConnection.ws = ws$1;
+			this.onOpen(url, targetConnection, oldWSConnection);
+		});
+		ws$1.on("message", (data) => {
+			this.onMessage(data.toString(), targetConnection);
+		});
+		ws$1.on("ping", () => {
+			this.logger.debug("Received PING from server");
+			this.emit("ping");
+			ws$1.pong();
+			this.logger.debug("Responded PONG to server's PING message");
+		});
+		ws$1.on("pong", () => {
+			this.logger.debug("Received PONG from server");
+			this.emit("pong");
+		});
+		ws$1.on("error", (err) => {
+			this.logger.error("Received error from server");
+			this.logger.error(err);
+			this.emit("error", err);
+		});
+		ws$1.on("close", (closeEventCode, reason) => {
+			this.emit("close", closeEventCode, reason);
+			if (!targetConnection.closeInitiated && !isRenewal) {
+				this.cleanup(ws$1);
+				this.logger.warn(`Connection with id ${targetConnection.id} closed due to ${closeEventCode}: ${reason}`);
+				this.scheduleTimer(ws$1, () => {
+					this.logger.info(`Reconnecting conection with id ${targetConnection.id} to the server.`);
+					targetConnection.isSessionLoggedOn = false;
+					targetConnection.reconnectionPending = true;
+					this.enqueueReconnection(targetConnection, this.getReconnectURL(url, targetConnection), false);
+				}, this.configuration?.reconnectDelay ?? 5e3);
+			}
+		});
+		return targetConnection;
+	}
+	/**
+	* Checks if the WebSocket connection is currently open.
+	* @param connection - An optional WebSocket connection to check. If not provided, the entire connection pool is checked.
+	* @returns `true` if the connection is open, `false` otherwise.
+	*/
+	isConnected(connection) {
+		return (connection ? [connection] : this.connectionPool).some((connection$1) => this.isConnectionReady(connection$1));
+	}
+	/**
+	* Disconnects from the WebSocket server.
+	* If there is no active connection, a warning is logged.
+	* Otherwise, all connections in the connection pool are closed gracefully,
+	* and a message is logged indicating that the connection has been disconnected.
+	* @returns A Promise that resolves when all connections have been closed.
+	* @throws Error if the WebSocket client is not set.
+	*/
+	async disconnect() {
+		if (!this.isConnected()) this.logger.warn("No connection to close.");
+		else {
+			this.connectionPool.forEach((connection) => {
+				connection.closeInitiated = true;
+				connection.isSessionLoggedOn = false;
+				connection.sessionLogonReq = void 0;
+			});
+			const disconnectPromises = this.connectionPool.map((connection) => this.closeConnectionGracefully(connection.ws, connection));
+			await Promise.all(disconnectPromises);
+			this.logger.info("Disconnected with Binance Websocket Server");
+		}
+	}
+	/**
+	* Sends a ping message to all connected Websocket servers in the pool.
+	* If no connections are ready, a warning is logged.
+	* For each active connection, the ping message is sent, and debug logs provide details.
+	* @throws Error if a Websocket client is not set for a connection.
+	*/
+	pingServer() {
+		const connectedConnections = this.connectionPool.filter((connection) => this.isConnected(connection));
+		if (connectedConnections.length === 0) {
+			this.logger.warn("Ping only can be sent when connection is ready.");
+			return;
+		}
+		this.logger.debug("Sending PING to all connected Websocket servers.");
+		connectedConnections.forEach((connection) => {
+			if (connection.ws) {
+				connection.ws.ping();
+				this.logger.debug(`PING sent to connection with id ${connection.id}`);
+			} else this.logger.error("WebSocket Client not set for a connection.");
+		});
+	}
+	/**
+	* Sends a payload through the WebSocket connection.
+	* @param payload - Message to send.
+	* @param id - Optional request identifier.
+	* @param promiseBased - Whether to return a promise.
+	* @param timeout - Timeout duration in milliseconds.
+	* @param connection - The WebSocket connection to use.
+	* @returns A promise if `promiseBased` is true, void otherwise.
+	* @throws Error if not connected or WebSocket client is not set.
+	*/
+	send(payload, id, promiseBased = true, timeout = 5e3, connection) {
+		if (!this.isConnected(connection)) {
+			const errorMsg = "Unable to send message — connection is not available.";
+			this.logger.warn(errorMsg);
+			if (promiseBased) return Promise.reject(new Error(errorMsg));
+			else throw new Error(errorMsg);
+		}
+		const connectionToUse = connection ?? this.getConnection();
+		if (!connectionToUse.ws) {
+			const errorMsg = "Websocket Client not set";
+			this.logger.error(errorMsg);
+			if (promiseBased) return Promise.reject(new Error(errorMsg));
+			else throw new Error(errorMsg);
+		}
+		connectionToUse.ws.send(payload);
+		if (promiseBased) return new Promise((resolve, reject) => {
+			if (!id) return reject(/* @__PURE__ */ new Error("id is required for promise-based sending."));
+			const timeoutHandle = setTimeout(() => {
+				if (connectionToUse.pendingRequests.has(id)) {
+					connectionToUse.pendingRequests.delete(id);
+					reject(/* @__PURE__ */ new Error(`Request timeout for id: ${id}`));
+				}
+			}, timeout);
+			connectionToUse.pendingRequests.set(id, {
+				resolve: (v) => {
+					clearTimeout(timeoutHandle);
+					resolve(v);
+				},
+				reject: (e) => {
+					clearTimeout(timeoutHandle);
+					reject(e);
+				}
+			});
+		});
+	}
 };
 var WebsocketAPIBase = class extends WebsocketCommon {
-  constructor(configuration, connectionPool = []) {
-    super(configuration, connectionPool);
-    this.isConnecting = false;
-    this.streamCallbackMap = /* @__PURE__ */ new Map();
-    this.logger = Logger.getInstance();
-    this.configuration = configuration;
-  }
-  /**
-   * Prepares the WebSocket URL by adding optional timeUnit parameter
-   * @param wsUrl The base WebSocket URL
-   * @returns The formatted WebSocket URL with parameters
-   */
-  prepareURL(wsUrl) {
-    let url = wsUrl;
-    if (this?.configuration.timeUnit) {
-      try {
-        const _timeUnit = validateTimeUnit(this.configuration.timeUnit);
-        url = `${url}${url.includes("?") ? "&" : "?"}timeUnit=${_timeUnit}`;
-      } catch (err) {
-        this.logger.error(err);
-      }
-    }
-    return url;
-  }
-  /**
-   * Processes incoming WebSocket messages
-   * @param data The raw message data received
-   */
-  onMessage(data, connection) {
-    try {
-      const message = (0, import_json_with_bigint2.JSONParse)(data);
-      const { id, status } = message;
-      if (id && connection.pendingRequests.has(id)) {
-        const request = connection.pendingRequests.get(id);
-        connection.pendingRequests.delete(id);
-        if (status && status >= 400) {
-          request?.reject(message.error);
-        } else {
-          const response = {
-            data: message.result ?? message.response,
-            ...message.rateLimits && { rateLimits: message.rateLimits }
-          };
-          request?.resolve(response);
-        }
-      } else if ("event" in message && "e" in message["event"] && this.streamCallbackMap.size > 0) {
-        this.streamCallbackMap.forEach(
-          (callbacks) => callbacks.forEach((callback) => callback(message["event"]))
-        );
-      } else {
-        this.logger.warn("Received response for unknown or timed-out request:", message);
-      }
-    } catch (error) {
-      this.logger.error("Failed to parse WebSocket message:", data, error);
-    }
-    super.onMessage(data, connection);
-  }
-  /**
-   * Establishes a WebSocket connection to Binance
-   * @returns Promise that resolves when connection is established
-   * @throws Error if connection times out
-   */
-  connect() {
-    if (this.isConnected()) {
-      this.logger.info("WebSocket connection already established");
-      return Promise.resolve();
-    }
-    return new Promise((resolve, reject) => {
-      if (this.isConnecting) return;
-      this.isConnecting = true;
-      const timeout = setTimeout(() => {
-        this.isConnecting = false;
-        reject(new Error("Websocket connection timed out"));
-      }, 1e4);
-      this.connectPool(this.prepareURL(this.configuration.wsURL)).then(() => {
-        this.isConnecting = false;
-        resolve();
-      }).catch((error) => {
-        this.isConnecting = false;
-        reject(error);
-      }).finally(() => {
-        clearTimeout(timeout);
-      });
-    });
-  }
-  async sendMessage(method, payload = {}, options = {}) {
-    if (!this.isConnected()) {
-      throw new Error("Not connected");
-    }
-    const isSessionReq = options.isSessionLogon || options.isSessionLogout;
-    const connections = isSessionReq ? this.getAvailableConnections() : [this.getConnection()];
-    const skipAuth = isSessionReq ? false : this.configuration.autoSessionReLogon && connections[0].isSessionLoggedOn;
-    const data = buildWebsocketAPIMessage(
-      this.configuration,
-      method,
-      payload,
-      options,
-      skipAuth
-    );
-    this.logger.debug("Send message to Binance WebSocket API Server:", data);
-    const responses = await Promise.all(
-      connections.map(
-        (connection) => this.send(
-          JSON.stringify(data),
-          data.id,
-          true,
-          this.configuration.timeout,
-          connection
-        )
-      )
-    );
-    if (isSessionReq && this.configuration.autoSessionReLogon) {
-      connections.forEach((connection) => {
-        if (options.isSessionLogon) {
-          connection.isSessionLoggedOn = true;
-          connection.sessionLogonReq = { method, payload, options };
-        } else {
-          connection.isSessionLoggedOn = false;
-          connection.sessionLogonReq = void 0;
-        }
-      });
-    }
-    return connections.length === 1 && !isSessionReq ? responses[0] : responses;
-  }
+	constructor(configuration, connectionPool = []) {
+		super(configuration, connectionPool);
+		this.isConnecting = false;
+		this.streamCallbackMap = /* @__PURE__ */ new Map();
+		this.logger = Logger.getInstance();
+		this.configuration = configuration;
+	}
+	/**
+	* Prepares the WebSocket URL by adding optional timeUnit parameter
+	* @param wsUrl The base WebSocket URL
+	* @returns The formatted WebSocket URL with parameters
+	*/
+	prepareURL(wsUrl) {
+		let url = wsUrl;
+		if (this?.configuration.timeUnit) try {
+			const _timeUnit = validateTimeUnit(this.configuration.timeUnit);
+			url = `${url}${url.includes("?") ? "&" : "?"}timeUnit=${_timeUnit}`;
+		} catch (err) {
+			this.logger.error(err);
+		}
+		return url;
+	}
+	/**
+	* Processes incoming WebSocket messages
+	* @param data The raw message data received
+	*/
+	onMessage(data, connection) {
+		try {
+			const message = (0, json_with_bigint.JSONParse)(data);
+			const { id, status } = message;
+			if (id && connection.pendingRequests.has(id)) {
+				const request = connection.pendingRequests.get(id);
+				connection.pendingRequests.delete(id);
+				if (status && status >= 400) request?.reject(message.error);
+				else {
+					const response = {
+						data: message.result ?? message.response,
+						...message.rateLimits && { rateLimits: message.rateLimits }
+					};
+					request?.resolve(response);
+				}
+			} else if ("event" in message && "e" in message["event"] && this.streamCallbackMap.size > 0) this.streamCallbackMap.forEach((callbacks) => callbacks.forEach((callback) => callback(message["event"])));
+			else this.logger.warn("Received response for unknown or timed-out request:", message);
+		} catch (error) {
+			this.logger.error("Failed to parse WebSocket message:", data, error);
+		}
+		super.onMessage(data, connection);
+	}
+	/**
+	* Establishes a WebSocket connection to Binance
+	* @returns Promise that resolves when connection is established
+	* @throws Error if connection times out
+	*/
+	connect() {
+		if (this.isConnected()) {
+			this.logger.info("WebSocket connection already established");
+			return Promise.resolve();
+		}
+		return new Promise((resolve, reject) => {
+			if (this.isConnecting) return;
+			this.isConnecting = true;
+			const timeout = setTimeout(() => {
+				this.isConnecting = false;
+				reject(/* @__PURE__ */ new Error("Websocket connection timed out"));
+			}, 1e4);
+			this.connectPool(this.prepareURL(this.configuration.wsURL)).then(() => {
+				this.isConnecting = false;
+				resolve();
+			}).catch((error) => {
+				this.isConnecting = false;
+				reject(error);
+			}).finally(() => {
+				clearTimeout(timeout);
+			});
+		});
+	}
+	async sendMessage(method, payload = {}, options = {}) {
+		if (!this.isConnected()) throw new Error("Not connected");
+		const isSessionReq = options.isSessionLogon || options.isSessionLogout;
+		const connections = isSessionReq ? this.getAvailableConnections() : [this.getConnection()];
+		const skipAuth = isSessionReq ? false : this.configuration.autoSessionReLogon && connections[0].isSessionLoggedOn;
+		const data = buildWebsocketAPIMessage(this.configuration, method, payload, options, skipAuth);
+		this.logger.debug("Send message to Binance WebSocket API Server:", data);
+		const responses = await Promise.all(connections.map((connection) => this.send(JSON.stringify(data), data.id, true, this.configuration.timeout, connection)));
+		if (isSessionReq && this.configuration.autoSessionReLogon) connections.forEach((connection) => {
+			if (options.isSessionLogon) {
+				connection.isSessionLoggedOn = true;
+				connection.sessionLogonReq = {
+					method,
+					payload,
+					options
+				};
+			} else {
+				connection.isSessionLoggedOn = false;
+				connection.sessionLogonReq = void 0;
+			}
+		});
+		return connections.length === 1 && !isSessionReq ? responses[0] : responses;
+	}
 };
 var WebsocketStreamsBase = class extends WebsocketCommon {
-  constructor(configuration, connectionPool = []) {
-    super(configuration, connectionPool);
-    this.streamConnectionMap = /* @__PURE__ */ new Map();
-    this.streamCallbackMap = /* @__PURE__ */ new Map();
-    this.logger = Logger.getInstance();
-    this.configuration = configuration;
-    this.wsURL = configuration.wsURL;
-  }
-  /**
-   * Formats the WebSocket URL for a given stream or streams.
-   * @param streams - Array of stream names to include in the URL.
-   * @returns The formatted WebSocket URL with the provided streams.
-   */
-  prepareURL(streams = []) {
-    let url = `${this.wsURL}/stream?streams=${streams.join("/")}`;
-    if (this.configuration?.timeUnit) {
-      try {
-        const _timeUnit = validateTimeUnit(this.configuration.timeUnit);
-        url = `${url}${url.includes("?") ? "&" : "?"}timeUnit=${_timeUnit}`;
-      } catch (err) {
-        this.logger.error(err);
-      }
-    }
-    return url;
-  }
-  /**
-   * Formats the WebSocket URL with stream and configuration parameters to be used for reconnection.
-   * @param url - The base WebSocket URL.
-   * @param targetConnection - The target WebSocket connection.
-   * @returns The formatted WebSocket URL with streams and optional parameters.
-   */
-  getReconnectURL(url, targetConnection) {
-    const streams = Array.from(this.streamConnectionMap.keys()).filter(
-      (stream) => this.streamConnectionMap.get(stream) === targetConnection
-    );
-    return this.prepareURL(streams);
-  }
-  /**
-   * Handles subscription to streams and assigns them to specific connections
-   * @param streams Array of stream names to subscribe to
-   * @returns Map of connections to streams
-   */
-  handleStreamAssignment(streams) {
-    const connectionStreamMap = /* @__PURE__ */ new Map();
-    streams.forEach((stream) => {
-      if (!this.streamCallbackMap.has(stream)) this.streamCallbackMap.set(stream, /* @__PURE__ */ new Set());
-      let connection = this.streamConnectionMap.get(stream);
-      if (!connection || connection.closeInitiated || connection.reconnectionPending) {
-        connection = this.getConnection(true);
-        this.streamConnectionMap.set(stream, connection);
-      }
-      if (!connectionStreamMap.has(connection)) connectionStreamMap.set(connection, []);
-      connectionStreamMap.get(connection)?.push(stream);
-    });
-    return connectionStreamMap;
-  }
-  /**
-   * Sends a subscription payload for specified streams on a given connection.
-   * @param connection The WebSocket connection to use for sending the subscription.
-   * @param streams The streams to subscribe to.
-   * @param id Optional ID for the subscription.
-   */
-  sendSubscriptionPayload(connection, streams, id) {
-    const payload = {
-      method: "SUBSCRIBE",
-      params: streams,
-      id: id && /^[0-9a-f]{32}$/.test(id) ? id : randomString()
-    };
-    this.logger.debug("SUBSCRIBE", payload);
-    this.send(JSON.stringify(payload), void 0, false, 0, connection);
-  }
-  /**
-   * Processes pending subscriptions for a given connection.
-   * Sends all queued subscriptions in a single payload.
-   * @param connection The WebSocket connection to process.
-   */
-  processPendingSubscriptions(connection) {
-    if (connection.pendingSubscriptions && connection.pendingSubscriptions.length > 0) {
-      this.logger.info("Processing queued subscriptions for connection");
-      this.sendSubscriptionPayload(connection, connection.pendingSubscriptions);
-      connection.pendingSubscriptions = [];
-    }
-  }
-  /**
-   * Handles incoming WebSocket messages, parsing the data and invoking the appropriate callback function.
-   * If the message contains a stream name that is registered in the `streamCallbackMap`, the corresponding
-   * callback function is called with the message data.
-   * If the message cannot be parsed, an error is logged.
-   * @param data The raw WebSocket message data.
-   * @param connection The WebSocket connection that received the message.
-   */
-  onMessage(data, connection) {
-    try {
-      const parsedData = (0, import_json_with_bigint2.JSONParse)(data);
-      const streamName = parsedData?.stream;
-      if (streamName && this.streamCallbackMap.has(streamName))
-        this.streamCallbackMap.get(streamName)?.forEach((callback) => callback(parsedData.data));
-    } catch (error) {
-      this.logger.error("Failed to parse WebSocket message:", data, error);
-    }
-    super.onMessage(data, connection);
-  }
-  /**
-   * Called when the WebSocket connection is opened.
-   * Processes any pending subscriptions for the target connection.
-   * @param url The URL of the WebSocket connection.
-   * @param targetConnection The WebSocket connection that was opened.
-   * @param oldConnection The previous WebSocket connection, if any.
-   */
-  onOpen(url, targetConnection, oldWSConnection) {
-    this.processPendingSubscriptions(targetConnection);
-    super.onOpen(url, targetConnection, oldWSConnection);
-  }
-  /**
-   * Connects to the WebSocket server and subscribes to the specified streams.
-   * This method returns a Promise that resolves when the connection is established,
-   * or rejects with an error if the connection fails to be established within 10 seconds.
-   * @param stream - A single stream name or an array of stream names to subscribe to.
-   * @returns A Promise that resolves when the connection is established.
-   */
-  connect(stream = []) {
-    const streams = Array.isArray(stream) ? stream : [stream];
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error("Websocket connection timed out"));
-      }, 1e4);
-      this.connectPool(this.prepareURL(streams)).then(() => resolve()).catch((error) => reject(error)).finally(() => clearTimeout(timeout));
-    });
-  }
-  /**
-   * Disconnects the WebSocket connection and clears the stream callback map.
-   * This method is called to clean up the connection and associated resources.
-   */
-  async disconnect() {
-    this.streamCallbackMap.clear();
-    this.streamConnectionMap.clear();
-    super.disconnect();
-  }
-  /**
-   * Subscribes to one or multiple WebSocket streams
-   * Handles both single and pool modes
-   * @param stream Single stream name or array of stream names to subscribe to
-   * @param id Optional subscription ID
-   * @returns void
-   */
-  subscribe(stream, id) {
-    const streams = (Array.isArray(stream) ? stream : [stream]).filter(
-      (stream2) => !this.streamConnectionMap.has(stream2)
-    );
-    const connectionStreamMap = this.handleStreamAssignment(streams);
-    connectionStreamMap.forEach((streams2, connection) => {
-      if (!this.isConnected(connection)) {
-        this.logger.info(
-          `Connection ${connection.id} is not ready. Queuing subscription for streams: ${streams2}`
-        );
-        connection.pendingSubscriptions?.push(...streams2);
-        return;
-      }
-      this.sendSubscriptionPayload(connection, streams2, id);
-    });
-  }
-  /**
-   * Unsubscribes from one or multiple WebSocket streams
-   * Handles both single and pool modes
-   * @param stream Single stream name or array of stream names to unsubscribe from
-   * @param id Optional unsubscription ID
-   * @returns void
-   */
-  unsubscribe(stream, id) {
-    const streams = Array.isArray(stream) ? stream : [stream];
-    streams.forEach((stream2) => {
-      const connection = this.streamConnectionMap.get(stream2);
-      if (!connection || !connection.ws || !this.isConnected(connection)) {
-        this.logger.warn(`Stream ${stream2} not associated with an active connection.`);
-        return;
-      }
-      if (!this.streamCallbackMap.has(stream2) || this.streamCallbackMap.get(stream2)?.size === 0) {
-        const payload = {
-          method: "UNSUBSCRIBE",
-          params: [stream2],
-          id: id && /^[0-9a-f]{32}$/.test(id) ? id : randomString()
-        };
-        this.logger.debug("UNSUBSCRIBE", payload);
-        this.send(JSON.stringify(payload), void 0, false, 0, connection);
-        this.streamConnectionMap.delete(stream2);
-        this.streamCallbackMap.delete(stream2);
-      }
-    });
-  }
-  /**
-   * Checks if the specified stream is currently subscribed.
-   * @param stream - The name of the stream to check.
-   * @returns `true` if the stream is currently subscribed, `false` otherwise.
-   */
-  isSubscribed(stream) {
-    return this.streamConnectionMap.has(stream);
-  }
+	constructor(configuration, connectionPool = []) {
+		super(configuration, connectionPool);
+		this.streamConnectionMap = /* @__PURE__ */ new Map();
+		this.streamCallbackMap = /* @__PURE__ */ new Map();
+		this.logger = Logger.getInstance();
+		this.configuration = configuration;
+		this.wsURL = configuration.wsURL;
+	}
+	/**
+	* Formats the WebSocket URL for a given stream or streams.
+	* @param streams - Array of stream names to include in the URL.
+	* @returns The formatted WebSocket URL with the provided streams.
+	*/
+	prepareURL(streams = []) {
+		let url = `${this.wsURL}/stream?streams=${streams.join("/")}`;
+		if (this.configuration?.timeUnit) try {
+			const _timeUnit = validateTimeUnit(this.configuration.timeUnit);
+			url = `${url}${url.includes("?") ? "&" : "?"}timeUnit=${_timeUnit}`;
+		} catch (err) {
+			this.logger.error(err);
+		}
+		return url;
+	}
+	/**
+	* Formats the WebSocket URL with stream and configuration parameters to be used for reconnection.
+	* @param url - The base WebSocket URL.
+	* @param targetConnection - The target WebSocket connection.
+	* @returns The formatted WebSocket URL with streams and optional parameters.
+	*/
+	getReconnectURL(url, targetConnection) {
+		const streams = Array.from(this.streamConnectionMap.keys()).filter((stream) => this.streamConnectionMap.get(stream) === targetConnection);
+		return this.prepareURL(streams);
+	}
+	/**
+	* Handles subscription to streams and assigns them to specific connections
+	* @param streams Array of stream names to subscribe to
+	* @returns Map of connections to streams
+	*/
+	handleStreamAssignment(streams) {
+		const connectionStreamMap = /* @__PURE__ */ new Map();
+		streams.forEach((stream) => {
+			if (!this.streamCallbackMap.has(stream)) this.streamCallbackMap.set(stream, /* @__PURE__ */ new Set());
+			let connection = this.streamConnectionMap.get(stream);
+			if (!connection || connection.closeInitiated || connection.reconnectionPending) {
+				connection = this.getConnection(true);
+				this.streamConnectionMap.set(stream, connection);
+			}
+			if (!connectionStreamMap.has(connection)) connectionStreamMap.set(connection, []);
+			connectionStreamMap.get(connection)?.push(stream);
+		});
+		return connectionStreamMap;
+	}
+	/**
+	* Sends a subscription payload for specified streams on a given connection.
+	* @param connection The WebSocket connection to use for sending the subscription.
+	* @param streams The streams to subscribe to.
+	* @param id Optional ID for the subscription.
+	*/
+	sendSubscriptionPayload(connection, streams, id) {
+		const payload = {
+			method: "SUBSCRIBE",
+			params: streams,
+			id: id && /^[0-9a-f]{32}$/.test(id) ? id : randomString()
+		};
+		this.logger.debug("SUBSCRIBE", payload);
+		this.send(JSON.stringify(payload), void 0, false, 0, connection);
+	}
+	/**
+	* Processes pending subscriptions for a given connection.
+	* Sends all queued subscriptions in a single payload.
+	* @param connection The WebSocket connection to process.
+	*/
+	processPendingSubscriptions(connection) {
+		if (connection.pendingSubscriptions && connection.pendingSubscriptions.length > 0) {
+			this.logger.info("Processing queued subscriptions for connection");
+			this.sendSubscriptionPayload(connection, connection.pendingSubscriptions);
+			connection.pendingSubscriptions = [];
+		}
+	}
+	/**
+	* Handles incoming WebSocket messages, parsing the data and invoking the appropriate callback function.
+	* If the message contains a stream name that is registered in the `streamCallbackMap`, the corresponding
+	* callback function is called with the message data.
+	* If the message cannot be parsed, an error is logged.
+	* @param data The raw WebSocket message data.
+	* @param connection The WebSocket connection that received the message.
+	*/
+	onMessage(data, connection) {
+		try {
+			const parsedData = (0, json_with_bigint.JSONParse)(data);
+			const streamName = parsedData?.stream;
+			if (streamName && this.streamCallbackMap.has(streamName)) this.streamCallbackMap.get(streamName)?.forEach((callback) => callback(parsedData.data));
+		} catch (error) {
+			this.logger.error("Failed to parse WebSocket message:", data, error);
+		}
+		super.onMessage(data, connection);
+	}
+	/**
+	* Called when the WebSocket connection is opened.
+	* Processes any pending subscriptions for the target connection.
+	* @param url The URL of the WebSocket connection.
+	* @param targetConnection The WebSocket connection that was opened.
+	* @param oldConnection The previous WebSocket connection, if any.
+	*/
+	onOpen(url, targetConnection, oldWSConnection) {
+		this.processPendingSubscriptions(targetConnection);
+		super.onOpen(url, targetConnection, oldWSConnection);
+	}
+	/**
+	* Connects to the WebSocket server and subscribes to the specified streams.
+	* This method returns a Promise that resolves when the connection is established,
+	* or rejects with an error if the connection fails to be established within 10 seconds.
+	* @param stream - A single stream name or an array of stream names to subscribe to.
+	* @returns A Promise that resolves when the connection is established.
+	*/
+	connect(stream = []) {
+		const streams = Array.isArray(stream) ? stream : [stream];
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("Websocket connection timed out"));
+			}, 1e4);
+			this.connectPool(this.prepareURL(streams)).then(() => resolve()).catch((error) => reject(error)).finally(() => clearTimeout(timeout));
+		});
+	}
+	/**
+	* Disconnects the WebSocket connection and clears the stream callback map.
+	* This method is called to clean up the connection and associated resources.
+	*/
+	async disconnect() {
+		this.streamCallbackMap.clear();
+		this.streamConnectionMap.clear();
+		super.disconnect();
+	}
+	/**
+	* Subscribes to one or multiple WebSocket streams
+	* Handles both single and pool modes
+	* @param stream Single stream name or array of stream names to subscribe to
+	* @param id Optional subscription ID
+	* @returns void
+	*/
+	subscribe(stream, id) {
+		const streams = (Array.isArray(stream) ? stream : [stream]).filter((stream$1) => !this.streamConnectionMap.has(stream$1));
+		this.handleStreamAssignment(streams).forEach((streams$1, connection) => {
+			if (!this.isConnected(connection)) {
+				this.logger.info(`Connection ${connection.id} is not ready. Queuing subscription for streams: ${streams$1}`);
+				connection.pendingSubscriptions?.push(...streams$1);
+				return;
+			}
+			this.sendSubscriptionPayload(connection, streams$1, id);
+		});
+	}
+	/**
+	* Unsubscribes from one or multiple WebSocket streams
+	* Handles both single and pool modes
+	* @param stream Single stream name or array of stream names to unsubscribe from
+	* @param id Optional unsubscription ID
+	* @returns void
+	*/
+	unsubscribe(stream, id) {
+		(Array.isArray(stream) ? stream : [stream]).forEach((stream$1) => {
+			const connection = this.streamConnectionMap.get(stream$1);
+			if (!connection || !connection.ws || !this.isConnected(connection)) {
+				this.logger.warn(`Stream ${stream$1} not associated with an active connection.`);
+				return;
+			}
+			if (!this.streamCallbackMap.has(stream$1) || this.streamCallbackMap.get(stream$1)?.size === 0) {
+				const payload = {
+					method: "UNSUBSCRIBE",
+					params: [stream$1],
+					id: id && /^[0-9a-f]{32}$/.test(id) ? id : randomString()
+				};
+				this.logger.debug("UNSUBSCRIBE", payload);
+				this.send(JSON.stringify(payload), void 0, false, 0, connection);
+				this.streamConnectionMap.delete(stream$1);
+				this.streamCallbackMap.delete(stream$1);
+			}
+		});
+	}
+	/**
+	* Checks if the specified stream is currently subscribed.
+	* @param stream - The name of the stream to check.
+	* @returns `true` if the stream is currently subscribed, `false` otherwise.
+	*/
+	isSubscribed(stream) {
+		return this.streamConnectionMap.has(stream);
+	}
 };
+/**
+* Creates a WebSocket stream handler for managing stream subscriptions and callbacks.
+*
+* @template T The type of data expected in the stream messages
+* @param {WebsocketAPIBase | WebsocketStreamsBase} websocketBase The WebSocket base instance
+* @param {string} streamOrId The stream identifier
+* @param {string} [id] Optional additional identifier
+* @returns {WebsocketStream<T>} A stream handler with methods to register callbacks and unsubscribe
+*/
 function createStreamHandler(websocketBase, streamOrId, id) {
-  if (websocketBase instanceof WebsocketStreamsBase) websocketBase.subscribe(streamOrId, id);
-  let registeredCallback;
-  return {
-    on: (event, callback) => {
-      if (event === "message") {
-        registeredCallback = (data) => {
-          Promise.resolve(callback(data)).catch((err) => {
-            websocketBase.logger.error(`Error in stream callback: ${err}`);
-          });
-        };
-        const callbackSet = websocketBase.streamCallbackMap.get(streamOrId) ?? /* @__PURE__ */ new Set();
-        callbackSet.add(registeredCallback);
-        websocketBase.streamCallbackMap.set(streamOrId, callbackSet);
-      }
-    },
-    unsubscribe: () => {
-      if (registeredCallback)
-        websocketBase.streamCallbackMap.get(streamOrId)?.delete(registeredCallback);
-      if (websocketBase instanceof WebsocketStreamsBase)
-        websocketBase.unsubscribe(streamOrId, id);
-    }
-  };
+	if (websocketBase instanceof WebsocketStreamsBase) websocketBase.subscribe(streamOrId, id);
+	let registeredCallback;
+	return {
+		on: (event, callback) => {
+			if (event === "message") {
+				registeredCallback = (data) => {
+					Promise.resolve(callback(data)).catch((err) => {
+						websocketBase.logger.error(`Error in stream callback: ${err}`);
+					});
+				};
+				const callbackSet = websocketBase.streamCallbackMap.get(streamOrId) ?? /* @__PURE__ */ new Set();
+				callbackSet.add(registeredCallback);
+				websocketBase.streamCallbackMap.set(streamOrId, callbackSet);
+			}
+		},
+		unsubscribe: () => {
+			if (registeredCallback) websocketBase.streamCallbackMap.get(streamOrId)?.delete(registeredCallback);
+			if (websocketBase instanceof WebsocketStreamsBase) websocketBase.unsubscribe(streamOrId, id);
+		}
+	};
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ALGO_REST_API_PROD_URL,
-  BadRequestError,
-  C2C_REST_API_PROD_URL,
-  CONVERT_REST_API_PROD_URL,
-  COPY_TRADING_REST_API_PROD_URL,
-  CRYPTO_LOAN_REST_API_PROD_URL,
-  ConfigurationRestAPI,
-  ConfigurationWebsocketAPI,
-  ConfigurationWebsocketStreams,
-  ConnectorClientError,
-  DERIVATIVES_TRADING_COIN_FUTURES_REST_API_PROD_URL,
-  DERIVATIVES_TRADING_COIN_FUTURES_REST_API_TESTNET_URL,
-  DERIVATIVES_TRADING_COIN_FUTURES_WS_API_PROD_URL,
-  DERIVATIVES_TRADING_COIN_FUTURES_WS_API_TESTNET_URL,
-  DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_PROD_URL,
-  DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_TESTNET_URL,
-  DERIVATIVES_TRADING_OPTIONS_REST_API_PROD_URL,
-  DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_PROD_URL,
-  DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_REST_API_PROD_URL,
-  DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_WS_STREAMS_PROD_URL,
-  DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_PROD_URL,
-  DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_TESTNET_URL,
-  DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_PROD_URL,
-  DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_TESTNET_URL,
-  DERIVATIVES_TRADING_USDS_FUTURES_REST_API_PROD_URL,
-  DERIVATIVES_TRADING_USDS_FUTURES_REST_API_TESTNET_URL,
-  DERIVATIVES_TRADING_USDS_FUTURES_WS_API_PROD_URL,
-  DERIVATIVES_TRADING_USDS_FUTURES_WS_API_TESTNET_URL,
-  DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_PROD_URL,
-  DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_TESTNET_URL,
-  DUAL_INVESTMENT_REST_API_PROD_URL,
-  FIAT_REST_API_PROD_URL,
-  ForbiddenError,
-  GIFT_CARD_REST_API_PROD_URL,
-  LogLevel,
-  Logger,
-  MARGIN_TRADING_REST_API_PROD_URL,
-  MARGIN_TRADING_RISK_WS_STREAMS_PROD_URL,
-  MARGIN_TRADING_WS_STREAMS_PROD_URL,
-  MINING_REST_API_PROD_URL,
-  NFT_REST_API_PROD_URL,
-  NetworkError,
-  NotFoundError,
-  PAY_REST_API_PROD_URL,
-  REBATE_REST_API_PROD_URL,
-  RateLimitBanError,
-  RequiredError,
-  SIMPLE_EARN_REST_API_PROD_URL,
-  SPOT_REST_API_MARKET_URL,
-  SPOT_REST_API_PROD_URL,
-  SPOT_REST_API_TESTNET_URL,
-  SPOT_WS_API_PROD_URL,
-  SPOT_WS_API_TESTNET_URL,
-  SPOT_WS_STREAMS_MARKET_URL,
-  SPOT_WS_STREAMS_PROD_URL,
-  SPOT_WS_STREAMS_TESTNET_URL,
-  STAKING_REST_API_PROD_URL,
-  SUB_ACCOUNT_REST_API_PROD_URL,
-  ServerError,
-  TimeUnit,
-  TooManyRequestsError,
-  UnauthorizedError,
-  VIP_LOAN_REST_API_PROD_URL,
-  WALLET_REST_API_PROD_URL,
-  WebsocketAPIBase,
-  WebsocketCommon,
-  WebsocketEventEmitter,
-  WebsocketStreamsBase,
-  assertParamExists,
-  buildQueryString,
-  buildUserAgent,
-  buildWebsocketAPIMessage,
-  clearSignerCache,
-  createStreamHandler,
-  delay,
-  getSignature,
-  getTimestamp,
-  httpRequestFunction,
-  normalizeScientificNumbers,
-  parseCustomHeaders,
-  parseRateLimitHeaders,
-  randomString,
-  removeEmptyValue,
-  replaceWebsocketStreamsPlaceholders,
-  sanitizeHeaderValue,
-  sendRequest,
-  setSearchParams,
-  shouldRetryRequest,
-  sortObject,
-  toPathString,
-  validateTimeUnit
-});
+
+//#endregion
+exports.ALGO_REST_API_PROD_URL = ALGO_REST_API_PROD_URL;
+exports.BadRequestError = BadRequestError;
+exports.C2C_REST_API_PROD_URL = C2C_REST_API_PROD_URL;
+exports.CONVERT_REST_API_PROD_URL = CONVERT_REST_API_PROD_URL;
+exports.COPY_TRADING_REST_API_PROD_URL = COPY_TRADING_REST_API_PROD_URL;
+exports.CRYPTO_LOAN_REST_API_PROD_URL = CRYPTO_LOAN_REST_API_PROD_URL;
+exports.ConfigurationRestAPI = ConfigurationRestAPI;
+exports.ConfigurationWebsocketAPI = ConfigurationWebsocketAPI;
+exports.ConfigurationWebsocketStreams = ConfigurationWebsocketStreams;
+exports.ConnectorClientError = ConnectorClientError;
+exports.DERIVATIVES_TRADING_COIN_FUTURES_REST_API_PROD_URL = DERIVATIVES_TRADING_COIN_FUTURES_REST_API_PROD_URL;
+exports.DERIVATIVES_TRADING_COIN_FUTURES_REST_API_TESTNET_URL = DERIVATIVES_TRADING_COIN_FUTURES_REST_API_TESTNET_URL;
+exports.DERIVATIVES_TRADING_COIN_FUTURES_WS_API_PROD_URL = DERIVATIVES_TRADING_COIN_FUTURES_WS_API_PROD_URL;
+exports.DERIVATIVES_TRADING_COIN_FUTURES_WS_API_TESTNET_URL = DERIVATIVES_TRADING_COIN_FUTURES_WS_API_TESTNET_URL;
+exports.DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_PROD_URL = DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_PROD_URL;
+exports.DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_TESTNET_URL = DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_TESTNET_URL;
+exports.DERIVATIVES_TRADING_OPTIONS_REST_API_PROD_URL = DERIVATIVES_TRADING_OPTIONS_REST_API_PROD_URL;
+exports.DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_PROD_URL = DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_PROD_URL;
+exports.DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_REST_API_PROD_URL = DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_REST_API_PROD_URL;
+exports.DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_WS_STREAMS_PROD_URL = DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_WS_STREAMS_PROD_URL;
+exports.DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_PROD_URL = DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_PROD_URL;
+exports.DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_TESTNET_URL = DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_TESTNET_URL;
+exports.DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_PROD_URL = DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_PROD_URL;
+exports.DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_TESTNET_URL = DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_TESTNET_URL;
+exports.DERIVATIVES_TRADING_USDS_FUTURES_REST_API_PROD_URL = DERIVATIVES_TRADING_USDS_FUTURES_REST_API_PROD_URL;
+exports.DERIVATIVES_TRADING_USDS_FUTURES_REST_API_TESTNET_URL = DERIVATIVES_TRADING_USDS_FUTURES_REST_API_TESTNET_URL;
+exports.DERIVATIVES_TRADING_USDS_FUTURES_WS_API_PROD_URL = DERIVATIVES_TRADING_USDS_FUTURES_WS_API_PROD_URL;
+exports.DERIVATIVES_TRADING_USDS_FUTURES_WS_API_TESTNET_URL = DERIVATIVES_TRADING_USDS_FUTURES_WS_API_TESTNET_URL;
+exports.DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_PROD_URL = DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_PROD_URL;
+exports.DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_TESTNET_URL = DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_TESTNET_URL;
+exports.DUAL_INVESTMENT_REST_API_PROD_URL = DUAL_INVESTMENT_REST_API_PROD_URL;
+exports.FIAT_REST_API_PROD_URL = FIAT_REST_API_PROD_URL;
+exports.ForbiddenError = ForbiddenError;
+exports.GIFT_CARD_REST_API_PROD_URL = GIFT_CARD_REST_API_PROD_URL;
+exports.LogLevel = LogLevel;
+exports.Logger = Logger;
+exports.MARGIN_TRADING_REST_API_PROD_URL = MARGIN_TRADING_REST_API_PROD_URL;
+exports.MARGIN_TRADING_RISK_WS_STREAMS_PROD_URL = MARGIN_TRADING_RISK_WS_STREAMS_PROD_URL;
+exports.MARGIN_TRADING_WS_STREAMS_PROD_URL = MARGIN_TRADING_WS_STREAMS_PROD_URL;
+exports.MINING_REST_API_PROD_URL = MINING_REST_API_PROD_URL;
+exports.NFT_REST_API_PROD_URL = NFT_REST_API_PROD_URL;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.PAY_REST_API_PROD_URL = PAY_REST_API_PROD_URL;
+exports.REBATE_REST_API_PROD_URL = REBATE_REST_API_PROD_URL;
+exports.RateLimitBanError = RateLimitBanError;
+exports.RequiredError = RequiredError;
+exports.SIMPLE_EARN_REST_API_PROD_URL = SIMPLE_EARN_REST_API_PROD_URL;
+exports.SPOT_REST_API_MARKET_URL = SPOT_REST_API_MARKET_URL;
+exports.SPOT_REST_API_PROD_URL = SPOT_REST_API_PROD_URL;
+exports.SPOT_REST_API_TESTNET_URL = SPOT_REST_API_TESTNET_URL;
+exports.SPOT_WS_API_PROD_URL = SPOT_WS_API_PROD_URL;
+exports.SPOT_WS_API_TESTNET_URL = SPOT_WS_API_TESTNET_URL;
+exports.SPOT_WS_STREAMS_MARKET_URL = SPOT_WS_STREAMS_MARKET_URL;
+exports.SPOT_WS_STREAMS_PROD_URL = SPOT_WS_STREAMS_PROD_URL;
+exports.SPOT_WS_STREAMS_TESTNET_URL = SPOT_WS_STREAMS_TESTNET_URL;
+exports.STAKING_REST_API_PROD_URL = STAKING_REST_API_PROD_URL;
+exports.SUB_ACCOUNT_REST_API_PROD_URL = SUB_ACCOUNT_REST_API_PROD_URL;
+exports.ServerError = ServerError;
+exports.TimeUnit = TimeUnit;
+exports.TooManyRequestsError = TooManyRequestsError;
+exports.UnauthorizedError = UnauthorizedError;
+exports.VIP_LOAN_REST_API_PROD_URL = VIP_LOAN_REST_API_PROD_URL;
+exports.WALLET_REST_API_PROD_URL = WALLET_REST_API_PROD_URL;
+exports.WebsocketAPIBase = WebsocketAPIBase;
+exports.WebsocketCommon = WebsocketCommon;
+exports.WebsocketEventEmitter = WebsocketEventEmitter;
+exports.WebsocketStreamsBase = WebsocketStreamsBase;
+exports.assertParamExists = assertParamExists;
+exports.buildQueryString = buildQueryString;
+exports.buildUserAgent = buildUserAgent;
+exports.buildWebsocketAPIMessage = buildWebsocketAPIMessage;
+exports.clearSignerCache = clearSignerCache;
+exports.createStreamHandler = createStreamHandler;
+exports.delay = delay;
+exports.getSignature = getSignature;
+exports.getTimestamp = getTimestamp;
+exports.httpRequestFunction = httpRequestFunction;
+exports.normalizeScientificNumbers = normalizeScientificNumbers;
+exports.parseCustomHeaders = parseCustomHeaders;
+exports.parseRateLimitHeaders = parseRateLimitHeaders;
+exports.randomString = randomString;
+exports.removeEmptyValue = removeEmptyValue;
+exports.replaceWebsocketStreamsPlaceholders = replaceWebsocketStreamsPlaceholders;
+exports.sanitizeHeaderValue = sanitizeHeaderValue;
+exports.sendRequest = sendRequest;
+exports.setSearchParams = setSearchParams;
+exports.shouldRetryRequest = shouldRetryRequest;
+exports.sortObject = sortObject;
+exports.toPathString = toPathString;
+exports.validateTimeUnit = validateTimeUnit;
 //# sourceMappingURL=index.js.map