topstepx-api 1.0.0

package/dist/index.mjs

@@ -0,0 +1,776 @@
+import { HubConnectionBuilder, HttpTransportType, HubConnectionState } from '@microsoft/signalr';
+
+// src/errors/base-error.ts
+var TopstepXError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = this.constructor.name;
+    this.timestamp = /* @__PURE__ */ new Date();
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  timestamp;
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      timestamp: this.timestamp.toISOString()
+    };
+  }
+};
+
+// src/errors/auth-error.ts
+var AuthenticationError = class extends TopstepXError {
+  constructor(message, code) {
+    super(message, code);
+  }
+};
+
+// src/errors/api-error.ts
+var ApiError = class extends TopstepXError {
+  constructor(message, code, endpoint) {
+    super(message, code);
+    this.endpoint = endpoint;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      endpoint: this.endpoint
+    };
+  }
+};
+
+// src/errors/connection-error.ts
+var ConnectionError = class extends TopstepXError {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/auth/auth.service.ts
+var AuthService = class {
+  sessionToken = null;
+  tokenExpiration = null;
+  refreshTimer;
+  config;
+  constructor(config) {
+    this.config = {
+      username: config.username,
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl ?? "https://api.topstepx.com",
+      autoRefresh: config.autoRefresh ?? true,
+      tokenValidityHours: config.tokenValidityHours ?? 24
+    };
+  }
+  async login() {
+    const request = {
+      userName: this.config.username,
+      apiKey: this.config.apiKey
+    };
+    const response = await fetch(`${this.config.baseUrl}/api/Auth/loginKey`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "text/plain"
+      },
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      throw new AuthenticationError(
+        `HTTP error during login: ${response.status}`,
+        response.status
+      );
+    }
+    const data = await response.json();
+    if (!data.success || data.errorCode !== 0) {
+      throw new AuthenticationError(
+        data.errorMessage ?? "Login failed",
+        data.errorCode
+      );
+    }
+    this.sessionToken = data.token;
+    this.setTokenExpiration();
+    if (this.config.autoRefresh) {
+      this.scheduleTokenRefresh();
+    }
+  }
+  async validate() {
+    if (!this.sessionToken) return false;
+    try {
+      const response = await fetch(`${this.config.baseUrl}/api/Auth/validate`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/plain",
+          Authorization: `Bearer ${this.sessionToken}`
+        }
+      });
+      if (response.ok) {
+        this.setTokenExpiration();
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  async getSessionToken() {
+    if (!this.sessionToken || this.isTokenExpired()) {
+      const isValid = await this.validate();
+      if (!isValid) {
+        await this.login();
+      }
+    }
+    if (!this.sessionToken) {
+      throw new AuthenticationError("No active session token available");
+    }
+    return this.sessionToken;
+  }
+  get baseUrl() {
+    return this.config.baseUrl;
+  }
+  setTokenExpiration() {
+    const expiration = /* @__PURE__ */ new Date();
+    expiration.setHours(
+      expiration.getHours() + this.config.tokenValidityHours
+    );
+    this.tokenExpiration = expiration;
+  }
+  isTokenExpired() {
+    if (!this.tokenExpiration) return true;
+    const buffer = 5 * 60 * 1e3;
+    return Date.now() >= this.tokenExpiration.getTime() - buffer;
+  }
+  scheduleTokenRefresh() {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+    }
+    if (!this.tokenExpiration) return;
+    const refreshTime = this.tokenExpiration.getTime() - Date.now() - 10 * 60 * 1e3;
+    if (refreshTime > 0) {
+      this.refreshTimer = setTimeout(async () => {
+        try {
+          const isValid = await this.validate();
+          if (!isValid) {
+            await this.login();
+          }
+          this.scheduleTokenRefresh();
+        } catch (error) {
+          console.error("Token refresh failed:", error);
+        }
+      }, refreshTime);
+    }
+  }
+  destroy() {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+    }
+    this.sessionToken = null;
+    this.tokenExpiration = null;
+  }
+};
+
+// src/rest/http-client.ts
+var HttpClient = class {
+  config;
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl,
+      getToken: config.getToken,
+      timeout: config.timeout ?? 3e4
+    };
+  }
+  async post(endpoint, data) {
+    const token = await this.config.getToken();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(`${this.config.baseUrl}${endpoint}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify(data),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new ApiError(
+          `HTTP error: ${response.status} ${response.statusText}`,
+          response.status,
+          endpoint
+        );
+      }
+      const result = await response.json();
+      if (!result.success || result.errorCode !== 0) {
+        throw new ApiError(
+          result.errorMessage ?? "API request failed",
+          result.errorCode,
+          endpoint
+        );
+      }
+      return result;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof ApiError) throw error;
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new ApiError("Request timeout", -1, endpoint);
+      }
+      throw new ApiError(
+        error instanceof Error ? error.message : "Unknown error",
+        -1,
+        endpoint
+      );
+    }
+  }
+};
+
+// src/rest/account/account.api.ts
+var AccountApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async search(request) {
+    const response = await this.http.post("/api/Account/search", request);
+    return response.accounts;
+  }
+};
+
+// src/rest/order/order.api.ts
+var OrderApi = class {
+  /** @internal */
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Search historical orders within a date range.
+   * @param request - Search parameters including accountId and optional date range
+   * @returns Array of orders matching the search criteria
+   */
+  async search(request) {
+    const response = await this.http.post("/api/Order/search", request);
+    return response.orders;
+  }
+  /**
+   * Get all currently open (working) orders for an account.
+   * @param request - Request containing the accountId
+   * @returns Array of open orders
+   */
+  async searchOpen(request) {
+    const response = await this.http.post("/api/Order/searchOpen", request);
+    return response.orders;
+  }
+  /**
+   * Place a new order.
+   * @param request - Order details including type, side, size, and prices
+   * @returns Response containing the new orderId
+   *
+   * @example
+   * ```typescript
+   * // Market order
+   * await client.orders.place({
+   *   accountId: 123,
+   *   contractId: 'CON.F.US.ENQ.M25',
+   *   type: OrderType.Market,
+   *   side: OrderSide.Buy,
+   *   size: 1,
+   * });
+   *
+   * // Limit order
+   * await client.orders.place({
+   *   accountId: 123,
+   *   contractId: 'CON.F.US.ENQ.M25',
+   *   type: OrderType.Limit,
+   *   side: OrderSide.Buy,
+   *   size: 1,
+   *   limitPrice: 5000.00,
+   * });
+   * ```
+   */
+  async place(request) {
+    return this.http.post(
+      "/api/Order/place",
+      request
+    );
+  }
+  /**
+   * Cancel an existing order.
+   * @param request - Request containing accountId and orderId to cancel
+   * @returns Response indicating success or failure
+   */
+  async cancel(request) {
+    return this.http.post(
+      "/api/Order/cancel",
+      request
+    );
+  }
+  /**
+   * Modify an existing order's size or price.
+   * @param request - Request containing orderId and fields to modify
+   * @returns Response indicating success or failure
+   */
+  async modify(request) {
+    return this.http.post(
+      "/api/Order/modify",
+      request
+    );
+  }
+};
+
+// src/rest/position/position.api.ts
+var PositionApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async searchOpen(request) {
+    const response = await this.http.post("/api/Position/searchOpen", request);
+    return response.positions;
+  }
+  async close(request) {
+    return this.http.post(
+      "/api/Position/closeContract",
+      request
+    );
+  }
+  async partialClose(request) {
+    return this.http.post("/api/Position/partialCloseContract", request);
+  }
+};
+
+// src/rest/trade/trade.api.ts
+var TradeApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async search(request) {
+    const response = await this.http.post("/api/Trade/search", request);
+    return response.trades;
+  }
+};
+
+// src/rest/contract/contract.api.ts
+var ContractApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async search(request) {
+    const response = await this.http.post("/api/Contract/search", request);
+    return response.contracts;
+  }
+  async searchById(request) {
+    const response = await this.http.post("/api/Contract/searchById", request);
+    return response.contract;
+  }
+};
+
+// src/rest/history/history.api.ts
+var HistoryApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async retrieveBars(request) {
+    const response = await this.http.post("/api/History/retrieveBars", request);
+    return response.bars;
+  }
+};
+var ConnectionManager = class {
+  marketConn = null;
+  userConn = null;
+  config;
+  marketConnectionCallbacks = [];
+  userConnectionCallbacks = [];
+  constructor(config) {
+    this.config = {
+      marketHubUrl: config.marketHubUrl,
+      userHubUrl: config.userHubUrl,
+      auth: config.auth,
+      reconnectDelays: config.reconnectDelays ?? [0, 2e3, 5e3, 1e4, 3e4]
+    };
+  }
+  async connect() {
+    const token = await this.config.auth.getSessionToken();
+    this.marketConn = new HubConnectionBuilder().withUrl(`${this.config.marketHubUrl}?access_token=${token}`, {
+      skipNegotiation: true,
+      transport: HttpTransportType.WebSockets,
+      accessTokenFactory: () => this.config.auth.getSessionToken()
+    }).withAutomaticReconnect(this.config.reconnectDelays).build();
+    this.userConn = new HubConnectionBuilder().withUrl(`${this.config.userHubUrl}?access_token=${token}`, {
+      skipNegotiation: true,
+      transport: HttpTransportType.WebSockets,
+      accessTokenFactory: () => this.config.auth.getSessionToken()
+    }).withAutomaticReconnect(this.config.reconnectDelays).build();
+    this.marketConnectionCallbacks.forEach((cb) => cb(this.marketConn));
+    this.userConnectionCallbacks.forEach((cb) => cb(this.userConn));
+    try {
+      await this.marketConn.start();
+      await this.userConn.start();
+    } catch (error) {
+      throw new ConnectionError(
+        `Failed to establish WebSocket connections: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  async disconnect() {
+    await Promise.all([this.marketConn?.stop(), this.userConn?.stop()]);
+    this.marketConn = null;
+    this.userConn = null;
+  }
+  get isConnected() {
+    return this.marketConn?.state === HubConnectionState.Connected && this.userConn?.state === HubConnectionState.Connected;
+  }
+  get marketConnection() {
+    if (!this.marketConn) {
+      throw new ConnectionError("Market connection not initialized");
+    }
+    return this.marketConn;
+  }
+  get userConnection() {
+    if (!this.userConn) {
+      throw new ConnectionError("User connection not initialized");
+    }
+    return this.userConn;
+  }
+  onMarketConnection(callback) {
+    this.marketConnectionCallbacks.push(callback);
+    if (this.marketConn) callback(this.marketConn);
+  }
+  onUserConnection(callback) {
+    this.userConnectionCallbacks.push(callback);
+    if (this.userConn) callback(this.userConn);
+  }
+};
+
+// src/utils/event-emitter.ts
+var TypedEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(callback);
+    return this;
+  }
+  off(event, callback) {
+    this.listeners.get(event)?.delete(callback);
+    return this;
+  }
+  once(event, callback) {
+    const onceCallback = ((data) => {
+      this.off(event, onceCallback);
+      callback(data);
+    });
+    return this.on(event, onceCallback);
+  }
+  emit(event, ...args) {
+    const callbacks = this.listeners.get(event);
+    if (!callbacks || callbacks.size === 0) return false;
+    callbacks.forEach((callback) => {
+      try {
+        if (args.length > 0) {
+          callback(args[0]);
+        } else {
+          callback();
+        }
+      } catch (error) {
+        console.error(`Error in event listener for ${String(event)}:`, error);
+      }
+    });
+    return true;
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+    return this;
+  }
+};
+
+// src/realtime/market/market-hub.ts
+var MarketHub = class extends TypedEventEmitter {
+  constructor(connectionManager) {
+    super();
+    this.connectionManager = connectionManager;
+    this.setupEventHandlers();
+  }
+  subscribedQuotes = /* @__PURE__ */ new Set();
+  subscribedTrades = /* @__PURE__ */ new Set();
+  subscribedDepth = /* @__PURE__ */ new Set();
+  setupEventHandlers() {
+    this.connectionManager.onMarketConnection((connection) => {
+      connection.on("GatewayQuote", (contractId, data) => {
+        this.emit("quote", { contractId, data });
+      });
+      connection.on(
+        "GatewayTrade",
+        (contractId, data) => {
+          this.emit("trade", { contractId, data });
+        }
+      );
+      connection.on(
+        "GatewayDepth",
+        (contractId, data) => {
+          this.emit("depth", { contractId, data });
+        }
+      );
+    });
+  }
+  async subscribe(contractId) {
+    await Promise.all([
+      this.subscribeQuotes(contractId),
+      this.subscribeTrades(contractId),
+      this.subscribeDepth(contractId)
+    ]);
+  }
+  async unsubscribe(contractId) {
+    await Promise.all([
+      this.unsubscribeQuotes(contractId),
+      this.unsubscribeTrades(contractId),
+      this.unsubscribeDepth(contractId)
+    ]);
+  }
+  async subscribeQuotes(contractId) {
+    if (this.subscribedQuotes.has(contractId)) return;
+    const connection = this.connectionManager.marketConnection;
+    await connection.invoke("SubscribeContractQuotes", contractId);
+    this.subscribedQuotes.add(contractId);
+  }
+  async unsubscribeQuotes(contractId) {
+    if (!this.subscribedQuotes.has(contractId)) return;
+    const connection = this.connectionManager.marketConnection;
+    await connection.invoke("UnsubscribeContractQuotes", contractId);
+    this.subscribedQuotes.delete(contractId);
+  }
+  async subscribeTrades(contractId) {
+    if (this.subscribedTrades.has(contractId)) return;
+    const connection = this.connectionManager.marketConnection;
+    await connection.invoke("SubscribeContractTrades", contractId);
+    this.subscribedTrades.add(contractId);
+  }
+  async unsubscribeTrades(contractId) {
+    if (!this.subscribedTrades.has(contractId)) return;
+    const connection = this.connectionManager.marketConnection;
+    await connection.invoke("UnsubscribeContractTrades", contractId);
+    this.subscribedTrades.delete(contractId);
+  }
+  async subscribeDepth(contractId) {
+    if (this.subscribedDepth.has(contractId)) return;
+    const connection = this.connectionManager.marketConnection;
+    await connection.invoke("SubscribeContractMarketDepth", contractId);
+    this.subscribedDepth.add(contractId);
+  }
+  async unsubscribeDepth(contractId) {
+    if (!this.subscribedDepth.has(contractId)) return;
+    const connection = this.connectionManager.marketConnection;
+    await connection.invoke("UnsubscribeContractMarketDepth", contractId);
+    this.subscribedDepth.delete(contractId);
+  }
+};
+
+// src/realtime/user/user-hub.ts
+var UserHub = class extends TypedEventEmitter {
+  constructor(connectionManager) {
+    super();
+    this.connectionManager = connectionManager;
+    this.setupEventHandlers();
+  }
+  subscribedOrders = /* @__PURE__ */ new Set();
+  subscribedPositions = /* @__PURE__ */ new Set();
+  subscribedTrades = /* @__PURE__ */ new Set();
+  setupEventHandlers() {
+    this.connectionManager.onUserConnection((connection) => {
+      connection.on("GatewayUserAccount", (data) => {
+        this.emit("account", data);
+      });
+      connection.on("GatewayUserOrder", (data) => {
+        this.emit("order", data);
+      });
+      connection.on("GatewayUserPosition", (data) => {
+        this.emit("position", data);
+      });
+      connection.on("GatewayUserTrade", (data) => {
+        this.emit("trade", data);
+      });
+    });
+  }
+  async subscribe(accountId) {
+    await Promise.all([
+      this.subscribeOrders(accountId),
+      this.subscribePositions(accountId),
+      this.subscribeTrades(accountId)
+    ]);
+  }
+  async unsubscribe(accountId) {
+    await Promise.all([
+      this.unsubscribeOrders(accountId),
+      this.unsubscribePositions(accountId),
+      this.unsubscribeTrades(accountId)
+    ]);
+  }
+  async subscribeOrders(accountId) {
+    if (this.subscribedOrders.has(accountId)) return;
+    const connection = this.connectionManager.userConnection;
+    await connection.invoke("SubscribeOrders", accountId);
+    this.subscribedOrders.add(accountId);
+  }
+  async unsubscribeOrders(accountId) {
+    if (!this.subscribedOrders.has(accountId)) return;
+    const connection = this.connectionManager.userConnection;
+    await connection.invoke("UnsubscribeOrders", accountId);
+    this.subscribedOrders.delete(accountId);
+  }
+  async subscribePositions(accountId) {
+    if (this.subscribedPositions.has(accountId)) return;
+    const connection = this.connectionManager.userConnection;
+    await connection.invoke("SubscribePositions", accountId);
+    this.subscribedPositions.add(accountId);
+  }
+  async unsubscribePositions(accountId) {
+    if (!this.subscribedPositions.has(accountId)) return;
+    const connection = this.connectionManager.userConnection;
+    await connection.invoke("UnsubscribePositions", accountId);
+    this.subscribedPositions.delete(accountId);
+  }
+  async subscribeTrades(accountId) {
+    if (this.subscribedTrades.has(accountId)) return;
+    const connection = this.connectionManager.userConnection;
+    await connection.invoke("SubscribeTrades", accountId);
+    this.subscribedTrades.add(accountId);
+  }
+  async unsubscribeTrades(accountId) {
+    if (!this.subscribedTrades.has(accountId)) return;
+    const connection = this.connectionManager.userConnection;
+    await connection.invoke("UnsubscribeTrades", accountId);
+    this.subscribedTrades.delete(accountId);
+  }
+};
+
+// src/client.ts
+var TopstepXClient = class extends TypedEventEmitter {
+  auth;
+  connectionManager;
+  httpClient;
+  /** Account management API */
+  accounts;
+  /** Order management API (place, cancel, modify, search) */
+  orders;
+  /** Position management API (search, close) */
+  positions;
+  /** Trade history API */
+  trades;
+  /** Contract/symbol search API */
+  contracts;
+  /** Historical bars/candles API */
+  history;
+  /** Real-time market data hub (quotes, trades, depth) */
+  marketHub;
+  /** Real-time account data hub (orders, positions, trades) */
+  userHub;
+  constructor(config) {
+    super();
+    const baseUrl = config.baseUrl ?? "https://api.topstepx.com";
+    this.auth = new AuthService({
+      username: config.username,
+      apiKey: config.apiKey,
+      baseUrl,
+      autoRefresh: config.autoRefresh ?? true,
+      tokenValidityHours: config.tokenValidityHours ?? 24
+    });
+    this.httpClient = new HttpClient({
+      baseUrl,
+      getToken: () => this.auth.getSessionToken()
+    });
+    this.accounts = new AccountApi(this.httpClient);
+    this.orders = new OrderApi(this.httpClient);
+    this.positions = new PositionApi(this.httpClient);
+    this.trades = new TradeApi(this.httpClient);
+    this.contracts = new ContractApi(this.httpClient);
+    this.history = new HistoryApi(this.httpClient);
+    this.connectionManager = new ConnectionManager({
+      marketHubUrl: config.marketHubUrl ?? "https://rtc.topstepx.com/hubs/market",
+      userHubUrl: config.userHubUrl ?? "https://rtc.topstepx.com/hubs/user",
+      auth: this.auth
+    });
+    this.marketHub = new MarketHub(this.connectionManager);
+    this.userHub = new UserHub(this.connectionManager);
+  }
+  /**
+   * Connect to the TopstepX API.
+   * Authenticates and establishes WebSocket connections.
+   */
+  async connect() {
+    await this.auth.login();
+    await this.connectionManager.connect();
+    this.emit("connected");
+  }
+  /**
+   * Disconnect from all services.
+   */
+  async disconnect() {
+    await this.connectionManager.disconnect();
+    this.auth.destroy();
+    this.emit("disconnected");
+  }
+  /**
+   * Check if client is connected.
+   */
+  get isConnected() {
+    return this.connectionManager.isConnected;
+  }
+  /**
+   * Get the current auth token (for advanced use cases).
+   */
+  async getToken() {
+    return this.auth.getSessionToken();
+  }
+};
+
+// src/types/enums.ts
+var OrderType = /* @__PURE__ */ ((OrderType2) => {
+  OrderType2[OrderType2["Limit"] = 1] = "Limit";
+  OrderType2[OrderType2["Market"] = 2] = "Market";
+  OrderType2[OrderType2["Stop"] = 3] = "Stop";
+  OrderType2[OrderType2["StopLimit"] = 4] = "StopLimit";
+  return OrderType2;
+})(OrderType || {});
+var OrderSide = /* @__PURE__ */ ((OrderSide2) => {
+  OrderSide2[OrderSide2["Buy"] = 0] = "Buy";
+  OrderSide2[OrderSide2["Sell"] = 1] = "Sell";
+  return OrderSide2;
+})(OrderSide || {});
+var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
+  OrderStatus2[OrderStatus2["Pending"] = 0] = "Pending";
+  OrderStatus2[OrderStatus2["Working"] = 1] = "Working";
+  OrderStatus2[OrderStatus2["Filled"] = 2] = "Filled";
+  OrderStatus2[OrderStatus2["Cancelled"] = 3] = "Cancelled";
+  OrderStatus2[OrderStatus2["Rejected"] = 4] = "Rejected";
+  OrderStatus2[OrderStatus2["PartiallyFilled"] = 5] = "PartiallyFilled";
+  return OrderStatus2;
+})(OrderStatus || {});
+var BarUnit = /* @__PURE__ */ ((BarUnit2) => {
+  BarUnit2[BarUnit2["Second"] = 1] = "Second";
+  BarUnit2[BarUnit2["Minute"] = 2] = "Minute";
+  BarUnit2[BarUnit2["Hour"] = 3] = "Hour";
+  BarUnit2[BarUnit2["Day"] = 4] = "Day";
+  BarUnit2[BarUnit2["Week"] = 5] = "Week";
+  BarUnit2[BarUnit2["Month"] = 6] = "Month";
+  return BarUnit2;
+})(BarUnit || {});
+var PositionType = /* @__PURE__ */ ((PositionType2) => {
+  PositionType2[PositionType2["Long"] = 0] = "Long";
+  PositionType2[PositionType2["Short"] = 1] = "Short";
+  return PositionType2;
+})(PositionType || {});
+var TradeType = /* @__PURE__ */ ((TradeType2) => {
+  TradeType2[TradeType2["Bid"] = 0] = "Bid";
+  TradeType2[TradeType2["Ask"] = 1] = "Ask";
+  return TradeType2;
+})(TradeType || {});
+
+export { AccountApi, ApiError, AuthService, AuthenticationError, BarUnit, ConnectionError, ConnectionManager, ContractApi, HistoryApi, HttpClient, MarketHub, OrderApi, OrderSide, OrderStatus, OrderType, PositionApi, PositionType, TopstepXClient, TopstepXError, TradeApi, TradeType, TypedEventEmitter, UserHub };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map