@pipsend/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1005 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/types/index.ts
+var PipsendError = class extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "PipsendError";
+  }
+};
+var AuthenticationError = class extends PipsendError {
+  constructor(message) {
+    super(message, "AUTH_ERROR", 401);
+    this.name = "AuthenticationError";
+  }
+};
+var ConfigurationError = class extends PipsendError {
+  constructor(message) {
+    super(message, "CONFIG_ERROR");
+    this.name = "ConfigurationError";
+  }
+};
+var WebSocketError = class extends PipsendError {
+  constructor(message) {
+    super(message, "WEBSOCKET_ERROR");
+    this.name = "WebSocketError";
+  }
+};
+
+// src/core/auth.ts
+var AuthManager = class {
+  constructor(config) {
+    this.config = config;
+    const marginMinutes = config.refreshMarginMinutes ?? 5;
+    this.refreshMarginMs = marginMinutes * 60 * 1e3;
+  }
+  /**
+   * Checks if a valid token is available
+   */
+  isAuthenticated() {
+    return !!this.tokenInfo && !this.isTokenExpired();
+  }
+  /**
+   * Gets the current token (if it exists and is valid)
+   */
+  getToken() {
+    if (this.isAuthenticated()) {
+      return this.tokenInfo?.token;
+    }
+    return void 0;
+  }
+  /**
+   * Ensures a valid token exists, authenticating if necessary
+   */
+  async ensureAuthenticated() {
+    if (!this.isAuthenticated()) {
+      await this.authenticate();
+    }
+    return this.tokenInfo.token;
+  }
+  /**
+   * Performs authentication with the server
+   * TODO: Implement real API call when available
+   */
+  async authenticate() {
+    try {
+      const mockResponse = {
+        token: "mock_token_" + Date.now(),
+        expiresIn: 180 * 60
+        // 180 minutes in seconds
+      };
+      this.setTokenInfo(mockResponse);
+      console.log("\u2705 Authentication successful (mock)");
+    } catch (error) {
+      if (error instanceof AuthenticationError) {
+        throw error;
+      }
+      throw new AuthenticationError(
+        `Authentication error: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Forces a re-authentication
+   */
+  async refreshToken() {
+    this.tokenInfo = void 0;
+    await this.authenticate();
+  }
+  /**
+   * Clears the current token
+   */
+  clearToken() {
+    this.tokenInfo = void 0;
+  }
+  /**
+   * Checks if the token is expired or about to expire
+   */
+  isTokenExpired() {
+    if (!this.tokenInfo) return true;
+    const now = Date.now();
+    const expiryWithMargin = this.tokenInfo.expiresAt.getTime() - this.refreshMarginMs;
+    return now >= expiryWithMargin;
+  }
+  /**
+   * Stores the received token information
+   */
+  setTokenInfo(response) {
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = new Date(now.getTime() + response.expiresIn * 1e3);
+    this.tokenInfo = {
+      token: response.token,
+      issuedAt: now,
+      expiresAt
+    };
+  }
+};
+
+// src/core/websocket.ts
+var WebSocketManager = class {
+  constructor(config, authManager) {
+    this.config = config;
+    this.authManager = authManager;
+    // WebSocket instance (browser or ws package)
+    this.reconnectAttempts = 0;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.isConnected = false;
+    this.subscribedChannels = [];
+    this.isReconnecting = false;
+  }
+  /**
+   * Connects to the WebSocket server
+   */
+  async connect() {
+    if (this.isConnected) {
+      console.log("\u26A0\uFE0F WebSocket already connected");
+      return;
+    }
+    if (this.isReconnecting) {
+      console.log("\u26A0\uFE0F WebSocket reconnection in progress");
+      return;
+    }
+    const wsUrl = this.buildWebSocketUrl();
+    const token = await this.authManager.ensureAuthenticated();
+    return new Promise((resolve, reject) => {
+      try {
+        const WS = this.getWebSocketConstructor();
+        this.ws = new WS(wsUrl);
+        this.ws.onopen = () => {
+          console.log("\u2705 WebSocket connected");
+          this.isConnected = true;
+          this.isReconnecting = false;
+          this.reconnectAttempts = 0;
+          this.send({
+            type: "auth",
+            payload: { token },
+            timestamp: Date.now()
+          });
+          this.emit("connected", { timestamp: Date.now() });
+          if (this.subscribedChannels.length > 0) {
+            console.log("\u{1F504} Resubscribing to channels:", this.subscribedChannels);
+            this.subscribe(this.subscribedChannels);
+          }
+          this.startHeartbeat();
+          resolve();
+        };
+        this.ws.onmessage = (event) => {
+          try {
+            const data = JSON.parse(event.data);
+            this.handleMessage(data);
+          } catch (error) {
+            console.error("\u274C Failed to parse WebSocket message:", error);
+          }
+        };
+        this.ws.onerror = (error) => {
+          console.error("\u274C WebSocket error:", error);
+          this.emit("error", error);
+          if (!this.isConnected) {
+            reject(new WebSocketError("Failed to connect to WebSocket server"));
+          }
+        };
+        this.ws.onclose = (event) => {
+          console.log("WebSocket disconnected", event.code, event.reason);
+          this.isConnected = false;
+          this.stopHeartbeat();
+          this.emit("disconnected", {
+            code: event.code,
+            reason: event.reason,
+            timestamp: Date.now()
+          });
+          this.handleReconnect();
+        };
+      } catch (error) {
+        reject(new WebSocketError(
+          `Failed to create WebSocket: ${error instanceof Error ? error.message : "Unknown error"}`
+        ));
+      }
+    });
+  }
+  /**
+   * Subscribes to channels (symbols, events, etc.)
+   * TODO: Adjust message format according to real WebSocket API
+   */
+  subscribe(channels) {
+    if (!this.isConnected) {
+      throw new WebSocketError("WebSocket not connected. Call connect() first.");
+    }
+    this.subscribedChannels = [.../* @__PURE__ */ new Set([...this.subscribedChannels, ...channels])];
+    this.send({
+      type: "subscribe",
+      payload: { channels },
+      timestamp: Date.now()
+    });
+    console.log("\u{1F4E1} Subscribed to channels:", channels);
+  }
+  /**
+   * Unsubscribes from channels
+   * TODO: Adjust message format according to real WebSocket API
+   */
+  unsubscribe(channels) {
+    if (!this.isConnected) {
+      console.warn("WebSocket not connected, cannot unsubscribe");
+      return;
+    }
+    this.subscribedChannels = this.subscribedChannels.filter(
+      (ch) => !channels.includes(ch)
+    );
+    this.send({
+      type: "unsubscribe",
+      payload: { channels },
+      timestamp: Date.now()
+    });
+    console.log("\u{1F4E1} Unsubscribed from channels:", channels);
+  }
+  /**
+   * Registers an event listener
+   */
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(callback);
+  }
+  /**
+   * Removes an event listener
+   */
+  off(event, callback) {
+    if (!callback) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.get(event)?.delete(callback);
+    }
+  }
+  /**
+   * Disconnects from WebSocket
+   */
+  disconnect() {
+    console.log("\u{1F44B} Disconnecting WebSocket...");
+    this.stopHeartbeat();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = void 0;
+    }
+    this.isConnected = false;
+    this.isReconnecting = false;
+    this.subscribedChannels = [];
+    this.listeners.clear();
+  }
+  /**
+   * Checks if WebSocket is connected
+   */
+  isWebSocketConnected() {
+    return this.isConnected;
+  }
+  /**
+   * Gets list of subscribed channels
+   */
+  getSubscribedChannels() {
+    return [...this.subscribedChannels];
+  }
+  // Private methods
+  /**
+   * Builds WebSocket URL from HTTP(S) server URL
+   */
+  buildWebSocketUrl() {
+    try {
+      const url = new URL(this.config.server);
+      url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+      const wsPath = this.config.websocket?.path || "/ws";
+      url.pathname = wsPath;
+      return url.toString();
+    } catch (error) {
+      throw new WebSocketError("Invalid server URL for WebSocket connection");
+    }
+  }
+  /**
+   * Gets WebSocket constructor (browser or Node.js)
+   */
+  getWebSocketConstructor() {
+    if (typeof WebSocket !== "undefined") {
+      return WebSocket;
+    }
+    try {
+      return __require("ws");
+    } catch {
+      throw new WebSocketError(
+        'WebSocket not available. Install "ws" package for Node.js: npm install ws'
+      );
+    }
+  }
+  /**
+   * Sends a message through WebSocket
+   */
+  send(message) {
+    if (!this.ws || !this.isConnected) {
+      console.warn("\u26A0\uFE0F WebSocket not ready, message not sent:", message.type);
+      return;
+    }
+    try {
+      const payload = JSON.stringify(message);
+      this.ws.send(payload);
+    } catch (error) {
+      console.error("\u274C Failed to send WebSocket message:", error);
+    }
+  }
+  /**
+   * Handles incoming WebSocket messages
+   * TODO: Adjust message handling according to real WebSocket API
+   */
+  handleMessage(data) {
+    if (data.type === "authenticated") {
+      console.log("\u2705 WebSocket authenticated");
+      this.emit("authenticated", data.payload || {});
+      return;
+    }
+    if (data.type === "pong") {
+      return;
+    }
+    const eventType = data.type;
+    this.emit(eventType, data.payload || data);
+    this.emit("*", data);
+  }
+  /**
+   * Emits an event to all registered listeners
+   */
+  emit(event, data) {
+    const listeners = this.listeners.get(event);
+    if (listeners && listeners.size > 0) {
+      listeners.forEach((callback) => {
+        try {
+          callback(data);
+        } catch (error) {
+          console.error(`\u274C Error in WebSocket listener for "${event}":`, error);
+        }
+      });
+    }
+  }
+  /**
+   * Handles reconnection logic with exponential backoff
+   */
+  handleReconnect() {
+    const autoReconnect = this.config.websocket?.autoReconnect ?? true;
+    const maxAttempts = this.config.websocket?.maxReconnectAttempts ?? 5;
+    if (!autoReconnect) {
+      console.log("Auto-reconnect disabled");
+      return;
+    }
+    if (this.reconnectAttempts >= maxAttempts) {
+      console.log(`\u274C Max reconnection attempts (${maxAttempts}) reached. Giving up.`);
+      this.emit("error", new WebSocketError("Max reconnection attempts reached"));
+      return;
+    }
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+    console.log(
+      `\u{1F504} Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts + 1}/${maxAttempts})...`
+    );
+    this.isReconnecting = true;
+    setTimeout(() => {
+      this.reconnectAttempts++;
+      this.connect().catch((error) => {
+        console.error("\u274C Reconnection failed:", error);
+      });
+    }, delay);
+  }
+  /**
+   * Starts heartbeat to keep connection alive
+   */
+  startHeartbeat() {
+    const interval = this.config.websocket?.heartbeatInterval || 3e4;
+    this.heartbeatTimer = setInterval(() => {
+      if (this.isConnected) {
+        this.send({
+          type: "ping",
+          timestamp: Date.now()
+        });
+      }
+    }, interval);
+  }
+  /**
+   * Stops heartbeat timer
+   */
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = void 0;
+    }
+  }
+};
+
+// src/api/http-client.ts
+var HttpClient = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Makes an HTTP request
+   */
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new PipsendError(
+          `HTTP ${response.status}: ${errorText || response.statusText}`,
+          "HTTP_ERROR",
+          response.status
+        );
+      }
+      const text = await response.text();
+      if (!text) {
+        return {};
+      }
+      return JSON.parse(text);
+    } catch (error) {
+      if (error instanceof PipsendError) {
+        throw error;
+      }
+      throw new PipsendError(
+        `Request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "NETWORK_ERROR"
+      );
+    }
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint, params) {
+    const queryString = params ? this.buildQueryString(params) : "";
+    const url = queryString ? `${endpoint}?${queryString}` : endpoint;
+    return this.request(url, { method: "GET" });
+  }
+  /**
+   * POST request
+   */
+  async post(endpoint, body) {
+    return this.request(endpoint, {
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * PUT request
+   */
+  async put(endpoint, body) {
+    return this.request(endpoint, {
+      method: "PUT",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(endpoint) {
+    return this.request(endpoint, { method: "DELETE" });
+  }
+  /**
+   * Builds query string from params object
+   */
+  buildQueryString(params) {
+    const filtered = Object.entries(params).filter(([_, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    return filtered.join("&");
+  }
+};
+
+// src/api/accounts.ts
+var AccountsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all accounts with optional filters and pagination
+   */
+  async list(params) {
+    return this.http.get("/api/v1/accounts", params);
+  }
+  /**
+   * Get all account logins
+   */
+  async getLogins() {
+    return this.http.get("/api/v1/accounts/logins");
+  }
+  /**
+   * Get account statistics with optional filters
+   */
+  async getStatistics(params) {
+    return this.http.get("/api/v1/accounts/statistics", params);
+  }
+  /**
+   * Change master password for an account
+   */
+  async changeMasterPassword(login, request) {
+    return this.http.put(`/api/v1/accounts/${login}/password/master`, request);
+  }
+  /**
+   * Change investor password for an account
+   */
+  async changeInvestorPassword(login, request) {
+    return this.http.put(`/api/v1/accounts/${login}/password/investor`, request);
+  }
+  /**
+   * Archive an account
+   */
+  async archive(login) {
+    return this.http.put(`/api/v1/accounts/${login}/archive`);
+  }
+  /**
+   * Unarchive an account
+   */
+  async unarchive(login) {
+    return this.http.put(`/api/v1/accounts/${login}/unarchive`);
+  }
+};
+
+// src/api/trading-groups.ts
+var TradingGroupsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all trading groups with optional filters
+   */
+  async list(params) {
+    return this.http.get("/api/v1/trading-groups", params);
+  }
+  /**
+   * Get trading group by name
+   */
+  async getByName(name) {
+    return this.http.get(`/api/v1/trading-groups/${encodeURIComponent(name)}`);
+  }
+  /**
+   * Get all trading group names
+   */
+  async getNames() {
+    return this.http.get("/api/v1/trading-groups/names");
+  }
+  /**
+   * Get trading group statistics
+   */
+  async getStatistics(type) {
+    return this.http.get("/api/v1/trading-groups/statistics", type ? { type } : void 0);
+  }
+};
+
+// src/api/market-data.ts
+var MarketDataAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get historical OHLCV candles
+   * 
+   * @param params - Candles parameters (symbol and timeframe are required)
+   * @returns Paginated candles or array of candles
+   * 
+   * @example
+   * ```ts
+   * // Get last 100 candles
+   * const candles = await client.marketData.getCandles({
+   *   symbol: 'BTCUSD',
+   *   timeframe: '1m',
+   *   limit: 100,
+   *   order: 'desc'
+   * });
+   * 
+   * // Get candles with time range
+   * const candles = await client.marketData.getCandles({
+   *   symbol: 'BTCUSD,ETHUSD',
+   *   timeframe: '1h',
+   *   from: '2025-11-01T00:00:00Z',
+   *   to: '2025-11-02T00:00:00Z'
+   * });
+   * ```
+   */
+  async getCandles(params) {
+    return this.http.get("/api/v1/candles", params);
+  }
+  /**
+   * Get available symbols with metadata
+   * 
+   * @param params - Optional filters for symbols
+   * @returns Paginated symbols or array of symbols
+   * 
+   * @example
+   * ```ts
+   * // Get all symbols
+   * const symbols = await client.marketData.getSymbols();
+   * 
+   * // Filter by group
+   * const cryptoSymbols = await client.marketData.getSymbols({
+   *   group: 'CRYPTO_MAJOR',
+   *   has_data: true
+   * });
+   * ```
+   */
+  async getSymbols(params) {
+    return this.http.get("/api/v1/symbols", params);
+  }
+  /**
+   * Get symbol groups hierarchy
+   * 
+   * Note: This endpoint never uses pagination
+   * 
+   * @param params - Optional filters for groups
+   * @returns Array of groups
+   * 
+   * @example
+   * ```ts
+   * // Get all groups
+   * const groups = await client.marketData.getGroups();
+   * 
+   * // Get only root groups
+   * const rootGroups = await client.marketData.getGroups({
+   *   root_only: true
+   * });
+   * ```
+   */
+  async getGroups(params) {
+    return this.http.get("/api/v1/groups", params);
+  }
+};
+
+// src/api/positions.ts
+var PositionsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List positions with optional filters and pagination
+   */
+  async list(params) {
+    return this.http.get("/api/v1/positions", params);
+  }
+  /**
+   * Get position statistics with optional filters and grouping
+   */
+  async getStats(params) {
+    return this.http.get("/api/v1/positions/stats", params);
+  }
+  /**
+   * Get position totals with dynamic grouping
+   */
+  async getTotals(params) {
+    return this.http.get("/api/v1/positions/totals", params);
+  }
+  /**
+   * Update position (modify SL/TP)
+   */
+  async update(id, request) {
+    return this.http.put(`/api/v1/positions/${id}`, request);
+  }
+  /**
+   * Delete (close) position
+   */
+  async delete(id, params) {
+    return this.http.delete(`/api/v1/positions/${id}?login=${params.login}`);
+  }
+  /**
+   * Check and recalculate positions
+   */
+  async check(request) {
+    return this.http.post("/api/v1/positions/check", request);
+  }
+};
+
+// src/api/orders.ts
+var OrdersAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List orders with optional filters and pagination
+   */
+  async list(params) {
+    return this.http.get("/api/v1/orders", params);
+  }
+  /**
+   * Get order statistics with optional filters and grouping
+   */
+  async getStats(params) {
+    return this.http.get("/api/v1/orders/stats", params);
+  }
+  /**
+   * Get order totals with dynamic grouping
+   */
+  async getTotals(params) {
+    return this.http.get("/api/v1/orders/totals", params);
+  }
+  /**
+   * Update order (modify SL/TP)
+   */
+  async update(id, request) {
+    return this.http.put(`/api/v1/orders/${id}`, request);
+  }
+  /**
+   * Delete (cancel) order
+   */
+  async delete(id, params) {
+    return this.http.delete(`/api/v1/orders/${id}?login=${params.login}`);
+  }
+  /**
+   * Check and validate pending orders
+   */
+  async check(request) {
+    return this.http.post("/api/v1/orders/check", request);
+  }
+};
+
+// src/api/trades.ts
+var TradesAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Open a new trade (market or pending order)
+   */
+  async open(request) {
+    return this.http.post("/api/v1/trades/open", request);
+  }
+  /**
+   * Close a trade (full or partial)
+   */
+  async close(request) {
+    return this.http.post("/api/v1/trades/close", request);
+  }
+  /**
+   * Modify trade Stop Loss and/or Take Profit
+   */
+  async modify(request) {
+    return this.http.put("/api/v1/trades/modify", request);
+  }
+  /**
+   * Check if there's sufficient margin for a trade
+   */
+  async checkMargin(request) {
+    return this.http.post("/api/v1/trades/check-margin", request);
+  }
+  /**
+   * Calculate potential profit for a trade
+   */
+  async calculateProfit(request) {
+    return this.http.post("/api/v1/trades/calc-profit", request);
+  }
+};
+
+// src/core/client.ts
+var PipsendClient = class {
+  constructor(config) {
+    /**
+     * Authentication API
+     * TODO: Implement when authentication is available
+     */
+    this.auth = {
+      /**
+       * Forces a token refresh
+       */
+      refresh: async () => {
+        await this.authManager.refreshToken();
+      },
+      /**
+       * Checks if the client is authenticated
+       */
+      isAuthenticated: () => {
+        return this.authManager.isAuthenticated();
+      },
+      /**
+       * Gets the current token (if it exists)
+       */
+      getToken: () => {
+        return this.authManager.getToken();
+      },
+      /**
+       * Logs out by clearing the token
+       */
+      logout: () => {
+        this.authManager.clearToken();
+      }
+    };
+    /**
+     * WebSocket streaming API
+     * Provides real-time updates for prices, orders, positions, etc.
+     */
+    this.stream = {
+      /**
+       * Connects to WebSocket server
+       */
+      connect: async () => {
+        if (!this.wsManager) {
+          throw new WebSocketError(
+            "WebSocket not enabled. Set websocket.enabled: true in config"
+          );
+        }
+        await this.wsManager.connect();
+      },
+      /**
+       * Disconnects from WebSocket server
+       */
+      disconnect: () => {
+        this.wsManager?.disconnect();
+      },
+      /**
+       * Checks if WebSocket is connected
+       */
+      isConnected: () => {
+        return this.wsManager?.isWebSocketConnected() ?? false;
+      },
+      /**
+       * Subscribes to symbols or channels
+       * @example
+       * client.stream.subscribe(['EURUSD', 'GBPUSD']);
+       */
+      subscribe: (channels) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.subscribe(channels);
+      },
+      /**
+       * Unsubscribes from symbols or channels
+       */
+      unsubscribe: (channels) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.unsubscribe(channels);
+      },
+      /**
+       * Gets list of subscribed channels
+       */
+      getSubscriptions: () => {
+        return this.wsManager?.getSubscribedChannels() ?? [];
+      },
+      /**
+       * Listens to real-time price updates
+       */
+      onPriceUpdate: (callback) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.on("price", callback);
+      },
+      /**
+       * Listens to real-time order updates
+       */
+      onOrderUpdate: (callback) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.on("order", callback);
+      },
+      /**
+       * Listens to real-time position updates
+       */
+      onPositionUpdate: (callback) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.on("position", callback);
+      },
+      /**
+       * Listens to real-time balance updates
+       */
+      onBalanceUpdate: (callback) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.on("balance", callback);
+      },
+      /**
+       * Listens to connection events
+       */
+      onConnected: (callback) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.on("connected", callback);
+      },
+      /**
+       * Listens to disconnection events
+       */
+      onDisconnected: (callback) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.on("disconnected", callback);
+      },
+      /**
+       * Listens to error events
+       */
+      onError: (callback) => {
+        if (!this.wsManager) {
+          throw new WebSocketError("WebSocket not enabled");
+        }
+        this.wsManager.on("error", callback);
+      },
+      /**
+       * Removes event listener
+       */
+      off: (event, callback) => {
+        this.wsManager?.off(event, callback);
+      }
+    };
+    this.validateConfig(config);
+    this.config = {
+      ...config,
+      autoRefresh: config.autoRefresh ?? true,
+      refreshMarginMinutes: config.refreshMarginMinutes ?? 5,
+      timezone: config.timezone ?? "UTC"
+    };
+    this.authManager = new AuthManager(this.config);
+    this.http = new HttpClient(this.config.server);
+    this.accounts = new AccountsAPI(this.http);
+    this.tradingGroups = new TradingGroupsAPI(this.http);
+    this.marketData = new MarketDataAPI(this.http);
+    this.positions = new PositionsAPI(this.http);
+    this.orders = new OrdersAPI(this.http);
+    this.trades = new TradesAPI(this.http);
+    if (config.websocket?.enabled) {
+      this.wsManager = new WebSocketManager(this.config, this.authManager);
+      if (config.websocket.autoConnect) {
+        this.wsManager.connect().catch((error) => {
+          console.error("Failed to auto-connect WebSocket:", error);
+        });
+      }
+    }
+  }
+  /**
+   * Validates the initial configuration
+   */
+  validateConfig(config) {
+    if (!config.server) {
+      throw new ConfigurationError('The "server" parameter is required');
+    }
+    try {
+      new URL(config.server);
+    } catch {
+      throw new ConfigurationError('The "server" parameter must be a valid URL');
+    }
+  }
+  /**
+   * Health check
+   */
+  async ping() {
+    return this.http.get("/ping");
+  }
+  /**
+   * Client information
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/index.ts
+function createClient(config) {
+  return new PipsendClient(config);
+}
+var sdk = {
+  createClient,
+  PipsendClient
+};
+var index_default = sdk;
+export {
+  AuthenticationError,
+  ConfigurationError,
+  PipsendClient,
+  PipsendError,
+  WebSocketError,
+  createClient,
+  index_default as default
+};
+//# sourceMappingURL=index.mjs.map