@piaa/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,822 @@
+// src/errors.ts
+class PiaError extends Error {
+  isPiaError = true;
+  statusCode;
+  endpoint;
+  method;
+  requestId;
+  constructor(message, details) {
+    super(message);
+    this.name = "PiaError";
+    this.statusCode = details?.statusCode;
+    this.endpoint = details?.endpoint;
+    this.method = details?.method;
+    this.requestId = details?.requestId;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class ConfigurationError extends PiaError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+}
+
+class ValidationError extends PiaError {
+  paramName;
+  constructor(message, paramName) {
+    super(message);
+    this.name = "ValidationError";
+    this.paramName = paramName;
+  }
+}
+
+class AuthenticationError extends PiaError {
+  constructor(message = "Authentication failed. Verify that your API key is valid and active.", details) {
+    super(message, details);
+    this.name = "AuthenticationError";
+  }
+}
+
+class PermissionError extends PiaError {
+  requiredScope;
+  constructor(message, requiredScope, details) {
+    super(message, details);
+    this.name = "PermissionError";
+    this.requiredScope = requiredScope;
+  }
+}
+
+class RateLimitError extends PiaError {
+  retryAfterSeconds;
+  dailyLimit;
+  dailyRemaining;
+  minuteLimit;
+  minuteRemaining;
+  constructor(message, options) {
+    super(message, options?.details);
+    this.name = "RateLimitError";
+    this.retryAfterSeconds = options?.retryAfterSeconds;
+    this.dailyLimit = options?.dailyLimit;
+    this.dailyRemaining = options?.dailyRemaining;
+    this.minuteLimit = options?.minuteLimit;
+    this.minuteRemaining = options?.minuteRemaining;
+  }
+}
+
+class TimeoutError extends PiaError {
+  timeoutMs;
+  constructor(message, timeoutMs, details) {
+    super(message, details);
+    this.name = "TimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+class NetworkError extends PiaError {
+  causeError;
+  constructor(message, cause, details) {
+    super(message, details);
+    this.name = "NetworkError";
+    this.causeError = cause;
+  }
+}
+
+class ParseError extends PiaError {
+  rawText;
+  constructor(message, rawText, details) {
+    super(message, details);
+    this.name = "ParseError";
+    this.rawText = rawText;
+  }
+}
+
+class ApiError extends PiaError {
+  rawBody;
+  constructor(message, statusCode, rawBody, details) {
+    super(message, { ...details, statusCode });
+    this.name = "ApiError";
+    this.rawBody = rawBody;
+  }
+}
+
+// src/logger.ts
+var SENSITIVE_KEY_PATTERNS = [
+  /wi_live_[a-zA-Z0-9_-]{10,}/g,
+  /Bearer\s+[a-zA-Z0-9._-]+/gi,
+  /api[_-]?key["':\s]+["']?([a-zA-Z0-9_-]+)["']?/gi,
+  /password["':\s]+["']?([^"'\s]+)["']?/gi
+];
+function redactSensitive(input) {
+  let redacted = input;
+  for (const pattern of SENSITIVE_KEY_PATTERNS) {
+    redacted = redacted.replace(pattern, (match) => {
+      if (match.startsWith("wi_live_")) {
+        return `wi_live_***${match.slice(-4)}`;
+      }
+      if (match.toLowerCase().startsWith("bearer ")) {
+        return "Bearer [REDACTED]";
+      }
+      return "[REDACTED]";
+    });
+  }
+  return redacted;
+}
+var LOG_LEVELS = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  silent: 50
+};
+
+class DefaultLogger {
+  levelNum;
+  prefix = "[PIA-SDK]";
+  constructor(level = "warn") {
+    this.levelNum = LOG_LEVELS[level] ?? LOG_LEVELS.warn;
+  }
+  safeFormat(msg, args) {
+    const cleanMsg = `${this.prefix} ${redactSensitive(msg)}`;
+    const cleanArgs = args.map((arg) => {
+      if (typeof arg === "string")
+        return redactSensitive(arg);
+      if (typeof arg === "object" && arg !== null) {
+        try {
+          return JSON.parse(redactSensitive(JSON.stringify(arg)));
+        } catch {
+          return "[Unserializable Object]";
+        }
+      }
+      return arg;
+    });
+    return [cleanMsg, ...cleanArgs];
+  }
+  debug(message, ...args) {
+    if (this.levelNum <= LOG_LEVELS.debug) {
+      const [msg, ...cleanArgs] = this.safeFormat(message, args);
+      console.debug(msg, ...cleanArgs);
+    }
+  }
+  info(message, ...args) {
+    if (this.levelNum <= LOG_LEVELS.info) {
+      const [msg, ...cleanArgs] = this.safeFormat(message, args);
+      console.info(msg, ...cleanArgs);
+    }
+  }
+  warn(message, ...args) {
+    if (this.levelNum <= LOG_LEVELS.warn) {
+      const [msg, ...cleanArgs] = this.safeFormat(message, args);
+      console.warn(msg, ...cleanArgs);
+    }
+  }
+  error(message, ...args) {
+    if (this.levelNum <= LOG_LEVELS.error) {
+      const [msg, ...cleanArgs] = this.safeFormat(message, args);
+      console.error(msg, ...cleanArgs);
+    }
+  }
+}
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://api-engine.wign.dev";
+var DEFAULT_WS_URL = "wss://api-engine.wign.dev/api/v1/ws";
+var DEFAULT_TIMEOUT_MS = 15000;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY_MS = 500;
+var DEFAULT_MAX_RETRY_DELAY_MS = 1e4;
+function resolveEnvApiKey() {
+  if (typeof process !== "undefined" && process?.env) {
+    return process.env.PIA_API_KEY || process.env.ATSLD_API_KEY || process.env.CORE_API_KEY || process.env.NEXT_PUBLIC_API_KEY;
+  }
+  return;
+}
+function resolveConfig(options = {}) {
+  const apiKey = options.apiKey?.trim() || resolveEnvApiKey()?.trim();
+  if (!apiKey) {
+    throw new ConfigurationError("API key is required. Pass { apiKey: '...' } to PiaClient or set the PIA_API_KEY environment variable.");
+  }
+  const rawBaseUrl = options.baseUrl?.trim() || DEFAULT_BASE_URL;
+  const baseUrl = rawBaseUrl.replace(/\/+$/, "");
+  try {
+    const parsed = new URL(baseUrl);
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      throw new Error("Protocol must be http or https");
+    }
+  } catch (err) {
+    throw new ConfigurationError(`Invalid baseUrl '${baseUrl}': ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const rawWsUrl = options.wsUrl?.trim() || DEFAULT_WS_URL;
+  const wsUrl = rawWsUrl.replace(/\/+$/, "");
+  try {
+    const parsedWs = new URL(wsUrl);
+    if (!["ws:", "wss:"].includes(parsedWs.protocol)) {
+      throw new Error("Protocol must be ws or wss");
+    }
+  } catch (err) {
+    throw new ConfigurationError(`Invalid wsUrl '${wsUrl}': ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  if (timeoutMs < 100) {
+    throw new ConfigurationError("timeoutMs must be at least 100 milliseconds.");
+  }
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  if (maxRetries < 0) {
+    throw new ConfigurationError("maxRetries cannot be negative.");
+  }
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  const maxRetryDelayMs = options.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+  const debug = options.debug ?? false;
+  const logLevel = options.logLevel ?? (debug ? "debug" : "warn");
+  const logger = options.logger ?? new DefaultLogger(logLevel);
+  const resolvedFetch = options.fetch || (typeof globalThis !== "undefined" && typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : undefined);
+  if (!resolvedFetch) {
+    throw new ConfigurationError("A valid fetch implementation was not found in the runtime. Pass a custom fetch to PiaClientOptions.");
+  }
+  const resolvedWebSocket = options.WebSocket || (typeof globalThis !== "undefined" && globalThis.WebSocket ? globalThis.WebSocket : undefined);
+  return {
+    apiKey,
+    baseUrl,
+    wsUrl,
+    timeoutMs,
+    maxRetries,
+    retryDelayMs,
+    maxRetryDelayMs,
+    headers: { ...options.headers || {} },
+    fetch: resolvedFetch,
+    WebSocket: resolvedWebSocket,
+    logger,
+    debug
+  };
+}
+
+// src/http/transport.ts
+var RETRYABLE_STATUS_CODES = new Set([408, 429, 500, 502, 503, 504]);
+var SDK_VERSION = "1.0.0";
+
+class HttpTransport {
+  config;
+  lastRateLimitInfo = {};
+  constructor(config) {
+    this.config = config;
+  }
+  getRateLimitInfo() {
+    return { ...this.lastRateLimitInfo };
+  }
+  async request(endpoint, method = "GET", body, options) {
+    const url = `${this.config.baseUrl}${endpoint.startsWith("/") ? "" : "/"}${endpoint}`;
+    const maxRetries = options?.maxRetries ?? this.config.maxRetries;
+    const timeoutMs = options?.timeoutMs ?? this.config.timeoutMs;
+    let attempt = 0;
+    while (true) {
+      attempt++;
+      this.config.logger.debug(`HTTP ${method} ${endpoint} (Attempt ${attempt}/${maxRetries + 1})`);
+      const controller = new AbortController;
+      let isTimedOut = false;
+      const timer = setTimeout(() => {
+        isTimedOut = true;
+        controller.abort();
+      }, timeoutMs);
+      if (options?.signal) {
+        if (options.signal.aborted) {
+          clearTimeout(timer);
+          throw options.signal.reason;
+        }
+        options.signal.addEventListener("abort", () => {
+          clearTimeout(timer);
+          controller.abort(options.signal?.reason);
+        }, { once: true });
+      }
+      try {
+        const headers = {
+          "x-api-key": this.config.apiKey,
+          Accept: "application/json",
+          "User-Agent": `pia-sdk-ts/${SDK_VERSION}`,
+          ...this.config.headers,
+          ...options?.headers || {}
+        };
+        let serializedBody;
+        if (body !== undefined) {
+          headers["Content-Type"] = "application/json";
+          serializedBody = JSON.stringify(body);
+        }
+        const response = await this.config.fetch(url, {
+          method,
+          headers,
+          body: serializedBody,
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        this.parseTelemetryHeaders(response.headers);
+        if (response.ok) {
+          return await this.parseResponseBody(response, endpoint, method);
+        }
+        const status = response.status;
+        const errorText = await response.text().catch(() => "");
+        let errorJson = null;
+        try {
+          if (errorText)
+            errorJson = JSON.parse(errorText);
+        } catch {}
+        const errorMessage = errorJson?.message || errorJson?.error || (errorText ? errorText.slice(0, 200) : `HTTP ${status}`);
+        const isRetryable = RETRYABLE_STATUS_CODES.has(status) && attempt <= maxRetries;
+        if (isRetryable) {
+          const delay = this.calculateBackoffDelay(attempt, response.headers);
+          this.config.logger.warn(`Request to ${endpoint} failed with HTTP ${status}. Retrying in ${delay}ms...`);
+          await this.sleep(delay);
+          continue;
+        }
+        this.handleHttpError(status, errorMessage, endpoint, method, response.headers, errorJson);
+      } catch (err) {
+        clearTimeout(timer);
+        if (isTimedOut) {
+          throw new TimeoutError(`Request to ${endpoint} exceeded timeout of ${timeoutMs}ms.`, timeoutMs, { endpoint, method });
+        }
+        if (options?.signal?.aborted) {
+          throw options.signal.reason;
+        }
+        if (err instanceof Error && "isPiaError" in err) {
+          throw err;
+        }
+        if (attempt <= maxRetries) {
+          const delay = this.calculateBackoffDelay(attempt);
+          this.config.logger.warn(`Network error calling ${endpoint}: ${err instanceof Error ? err.message : String(err)}. Retrying in ${delay}ms...`);
+          await this.sleep(delay);
+          continue;
+        }
+        throw new NetworkError(`Network transport failed connecting to ${endpoint}: ${err instanceof Error ? err.message : String(err)}`, err, { endpoint, method });
+      }
+    }
+  }
+  parseTelemetryHeaders(headers) {
+    const parseNum = (name) => {
+      const val = headers.get(name);
+      if (!val)
+        return;
+      const num = parseInt(val, 10);
+      return Number.isFinite(num) ? num : undefined;
+    };
+    this.lastRateLimitInfo = {
+      limit: parseNum("x-ratelimit-limit"),
+      remaining: parseNum("x-ratelimit-remaining"),
+      resetSeconds: parseNum("x-ratelimit-reset"),
+      dailyLimit: parseNum("x-dailyquota-limit"),
+      dailyRemaining: parseNum("x-dailyquota-remaining")
+    };
+  }
+  calculateBackoffDelay(attempt, headers) {
+    const retryAfter = headers?.get("retry-after");
+    if (retryAfter) {
+      const parsedSeconds = parseInt(retryAfter, 10);
+      if (Number.isFinite(parsedSeconds) && parsedSeconds > 0) {
+        return Math.min(parsedSeconds * 1000, this.config.maxRetryDelayMs);
+      }
+    }
+    const base = this.config.retryDelayMs * Math.pow(2, attempt - 1);
+    const capped = Math.min(base, this.config.maxRetryDelayMs);
+    const jitter = 0.5 + Math.random() * 0.5;
+    return Math.round(capped * jitter);
+  }
+  async parseResponseBody(response, endpoint, method) {
+    const text = await response.text();
+    if (!text || text.trim() === "") {
+      return {};
+    }
+    try {
+      return JSON.parse(text);
+    } catch (err) {
+      throw new ParseError(`Failed to parse JSON response from ${endpoint}: ${err instanceof Error ? err.message : String(err)}`, text.slice(0, 500), { statusCode: response.status, endpoint, method });
+    }
+  }
+  handleHttpError(status, message, endpoint, method, headers, body) {
+    const details = {
+      statusCode: status,
+      endpoint,
+      method,
+      requestId: headers.get("x-request-id") || headers.get("cf-ray"),
+      rawResponse: body
+    };
+    if (status === 401) {
+      throw new AuthenticationError(message, details);
+    }
+    if (status === 403) {
+      throw new PermissionError(message, undefined, details);
+    }
+    if (status === 429) {
+      const retryAfter = headers.get("retry-after");
+      const retryAfterSeconds = retryAfter ? parseInt(retryAfter, 10) : undefined;
+      throw new RateLimitError(message, {
+        retryAfterSeconds: Number.isFinite(retryAfterSeconds) ? retryAfterSeconds : undefined,
+        dailyLimit: this.lastRateLimitInfo.dailyLimit,
+        dailyRemaining: this.lastRateLimitInfo.dailyRemaining,
+        minuteLimit: this.lastRateLimitInfo.limit,
+        minuteRemaining: this.lastRateLimitInfo.remaining,
+        details
+      });
+    }
+    throw new ApiError(message, status, body, details);
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+// src/realtime/events.ts
+class TypedEventEmitter {
+  listeners = new Map;
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set);
+    }
+    this.listeners.get(event).add(listener);
+    return this;
+  }
+  off(event, listener) {
+    const set = this.listeners.get(event);
+    if (set) {
+      set.delete(listener);
+      if (set.size === 0) {
+        this.listeners.delete(event);
+      }
+    }
+    return this;
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set || set.size === 0)
+      return false;
+    for (const listener of Array.from(set)) {
+      try {
+        listener(...args);
+      } catch (err) {
+        console.error(`[PIA-SDK] Unhandled error in '${event}' listener:`, err);
+      }
+    }
+    return true;
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+    return this;
+  }
+}
+
+// src/realtime/socket.ts
+class RealtimeClient extends TypedEventEmitter {
+  config;
+  ws = null;
+  state = "DISCONNECTED";
+  subscribedSymbols = new Set;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  isExplicitlyClosed = false;
+  pingIntervalTimer = null;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  getState() {
+    return this.state;
+  }
+  connect() {
+    if (this.state === "CONNECTING" || this.state === "AUTHENTICATING" || this.state === "AUTHENTICATED") {
+      this.config.logger.debug("Socket already active or connecting.");
+      return this;
+    }
+    this.isExplicitlyClosed = false;
+    this.initiateConnection();
+    return this;
+  }
+  initiateConnection() {
+    const WsConstructor = this.config.WebSocket || typeof globalThis !== "undefined" && globalThis.WebSocket;
+    if (!WsConstructor) {
+      throw new ConfigurationError("WebSocket implementation not available. In Node.js environments, pass { WebSocket: require('ws') } in options.");
+    }
+    this.state = "CONNECTING";
+    this.config.logger.info(`Connecting to Realtime WebSocket: ${this.config.wsUrl}`);
+    try {
+      this.ws = new WsConstructor(this.config.wsUrl);
+    } catch (err) {
+      this.handleSocketFailure(err);
+      return;
+    }
+    this.ws.onopen = () => {
+      this.config.logger.info("WebSocket TCP connection opened. Initiating In-Band Auth...");
+      this.state = "AUTHENTICATING";
+      this.reconnectAttempt = 0;
+      this.emit("connect");
+      this.sendRaw({
+        action: "auth",
+        api_key: this.config.apiKey
+      });
+      this.startHeartbeat();
+    };
+    this.ws.onmessage = (event) => {
+      this.handleIncomingMessage(event.data);
+    };
+    this.ws.onerror = (event) => {
+      const err = new NetworkError("WebSocket connection error", event?.message || event?.error || event);
+      this.config.logger.error("WebSocket error:", err.message);
+      this.emit("error", err);
+    };
+    this.ws.onclose = (event) => {
+      const code = event?.code ?? 1006;
+      const reason = event?.reason ?? "";
+      const wasClean = event?.wasClean ?? false;
+      this.stopHeartbeat();
+      this.state = "DISCONNECTED";
+      this.ws = null;
+      this.config.logger.warn(`WebSocket closed: code=${code}, reason=${reason}`);
+      this.emit("disconnect", { code, reason, wasClean });
+      if (code === 4001 || reason.toLowerCase().includes("unauthorized")) {
+        this.emit("error", new AuthenticationError("WebSocket authentication rejected by server."));
+        return;
+      }
+      if (!this.isExplicitlyClosed) {
+        this.scheduleReconnect();
+      }
+    };
+  }
+  handleIncomingMessage(rawPayload) {
+    let messageText;
+    if (typeof rawPayload === "string") {
+      messageText = rawPayload;
+    } else if (rawPayload instanceof ArrayBuffer || typeof Buffer !== "undefined" && Buffer && Buffer.isBuffer(rawPayload)) {
+      messageText = new TextDecoder().decode(rawPayload);
+    } else {
+      messageText = String(rawPayload);
+    }
+    let payload;
+    try {
+      payload = JSON.parse(messageText);
+    } catch {
+      this.emit("raw", messageText);
+      return;
+    }
+    this.emit("raw", payload);
+    if (payload.event === "authenticated") {
+      this.state = "AUTHENTICATED";
+      this.config.logger.info("WebSocket authenticated successfully.");
+      this.emit("authenticated", payload.data || {});
+      if (this.subscribedSymbols.size > 0) {
+        this.flushSubscriptions();
+      }
+      return;
+    }
+    if (payload.event === "market.trade" || payload.event === "market.tick") {
+      const tick = payload.data?.tick || payload.data;
+      if (tick) {
+        this.emit("tick", tick);
+      }
+      return;
+    }
+    if (payload.event === "market.snapshot" && payload.data) {
+      this.emit("snapshot", payload.data);
+      return;
+    }
+    if (payload.error) {
+      if (payload.error === "unauthorized" || payload.error === 401) {
+        this.emit("error", new AuthenticationError(payload.message || "Unauthorized WebSocket message."));
+      } else {
+        this.emit("error", new NetworkError(payload.message || `Server reported error: ${payload.error}`));
+      }
+    }
+  }
+  subscribe(symbols) {
+    const list = Array.isArray(symbols) ? symbols : [symbols];
+    const newSymbols = [];
+    for (const sym of list) {
+      const clean = sym.trim().toUpperCase();
+      if (clean && !this.subscribedSymbols.has(clean)) {
+        this.subscribedSymbols.add(clean);
+        newSymbols.push(clean);
+      }
+    }
+    if (newSymbols.length > 0 && this.state === "AUTHENTICATED") {
+      this.sendRaw({
+        action: "subscribe",
+        symbols: newSymbols
+      });
+    }
+    return this;
+  }
+  unsubscribe(symbols) {
+    const list = Array.isArray(symbols) ? symbols : [symbols];
+    const removed = [];
+    for (const sym of list) {
+      const clean = sym.trim().toUpperCase();
+      if (this.subscribedSymbols.delete(clean)) {
+        removed.push(clean);
+      }
+    }
+    if (removed.length > 0 && this.state === "AUTHENTICATED") {
+      this.sendRaw({
+        action: "unsubscribe",
+        symbols: removed
+      });
+    }
+    return this;
+  }
+  flushSubscriptions() {
+    if (this.subscribedSymbols.size === 0)
+      return;
+    this.sendRaw({
+      action: "subscribe",
+      symbols: Array.from(this.subscribedSymbols)
+    });
+  }
+  sendRaw(data) {
+    if (!this.ws || this.ws.readyState !== 1) {
+      return false;
+    }
+    try {
+      this.ws.send(JSON.stringify(data));
+      return true;
+    } catch (err) {
+      this.config.logger.error("Failed to send WebSocket message:", err);
+      return false;
+    }
+  }
+  scheduleReconnect() {
+    this.reconnectAttempt++;
+    const delay = Math.min(1000 * Math.pow(1.5, this.reconnectAttempt - 1), 15000);
+    const jitteredDelay = Math.round(delay * (0.8 + Math.random() * 0.4));
+    this.config.logger.info(`Reconnecting in ${jitteredDelay}ms (Attempt ${this.reconnectAttempt})...`);
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = setTimeout(() => {
+      if (!this.isExplicitlyClosed) {
+        this.initiateConnection();
+      }
+    }, jitteredDelay);
+  }
+  handleSocketFailure(err) {
+    this.state = "DISCONNECTED";
+    this.ws = null;
+    const netErr = new NetworkError("Failed to initiate WebSocket connection", err);
+    this.emit("error", netErr);
+    if (!this.isExplicitlyClosed) {
+      this.scheduleReconnect();
+    }
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.pingIntervalTimer = setInterval(() => {
+      if (this.state === "AUTHENTICATED") {
+        this.sendRaw({ action: "ping" });
+      }
+    }, 30000);
+  }
+  stopHeartbeat() {
+    if (this.pingIntervalTimer) {
+      clearInterval(this.pingIntervalTimer);
+      this.pingIntervalTimer = null;
+    }
+  }
+  disconnect() {
+    this.isExplicitlyClosed = true;
+    this.stopHeartbeat();
+    clearTimeout(this.reconnectTimer);
+    if (this.ws) {
+      this.state = "CLOSING";
+      try {
+        this.ws.close(1000, "Client disconnect");
+      } catch {}
+      this.ws = null;
+    }
+    this.state = "DISCONNECTED";
+  }
+}
+
+// src/resources/market.ts
+class MarketResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async getPrices(options) {
+    return this.transport.request("/api/v1/market/prices", "GET", undefined, options);
+  }
+  async getCandles(symbol, options) {
+    if (!symbol || typeof symbol !== "string" || symbol.trim() === "") {
+      throw new ValidationError("Symbol must be a non-empty string.", "symbol");
+    }
+    const cleanSymbol = symbol.trim().toUpperCase();
+    const params = new URLSearchParams;
+    if (options?.timeframe)
+      params.set("tf", options.timeframe);
+    if (options?.limit)
+      params.set("limit", String(options.limit));
+    if (options?.since)
+      params.set("since", String(options.since));
+    if (options?.until)
+      params.set("until", String(options.until));
+    const query = params.toString() ? `?${params.toString()}` : "";
+    return this.transport.request(`/api/v1/market/candles/${encodeURIComponent(cleanSymbol)}${query}`, "GET", undefined, options);
+  }
+  async getOrderBook(symbol, options) {
+    if (!symbol || typeof symbol !== "string" || symbol.trim() === "") {
+      throw new ValidationError("Symbol must be a non-empty string.", "symbol");
+    }
+    const cleanSymbol = symbol.trim().toUpperCase();
+    return this.transport.request(`/api/v1/market/orderbook/${encodeURIComponent(cleanSymbol)}`, "GET", undefined, options);
+  }
+}
+
+// src/resources/news.ts
+class NewsResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async getNews(options) {
+    const params = new URLSearchParams;
+    if (options?.symbols && options.symbols.length > 0) {
+      params.set("symbols", options.symbols.map((s) => s.trim().toUpperCase()).join(","));
+    }
+    if (options?.limit)
+      params.set("limit", String(options.limit));
+    const query = params.toString() ? `?${params.toString()}` : "";
+    return this.transport.request(`/api/v1/news${query}`, "GET", undefined, options);
+  }
+}
+
+// src/resources/social.ts
+class SocialResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async getPosts(options) {
+    const params = new URLSearchParams;
+    if (options?.symbol)
+      params.set("symbol", options.symbol.trim().toUpperCase());
+    if (options?.limit)
+      params.set("limit", String(options.limit));
+    if (options?.cursor)
+      params.set("cursor", options.cursor);
+    const query = params.toString() ? `?${params.toString()}` : "";
+    return this.transport.request(`/api/v1/social/posts${query}`, "GET", undefined, options);
+  }
+}
+
+// src/resources/ws.ts
+class WsResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async createTicket(options) {
+    return this.transport.request("/api/v1/ws/ticket", "POST", {}, options);
+  }
+}
+
+// src/client.ts
+class PiaClient {
+  config;
+  transport;
+  market;
+  social;
+  news;
+  ws;
+  realtime;
+  constructor(options = {}) {
+    this.config = Object.freeze(resolveConfig(options));
+    this.transport = new HttpTransport(this.config);
+    this.market = new MarketResource(this.transport);
+    this.social = new SocialResource(this.transport);
+    this.news = new NewsResource(this.transport);
+    this.ws = new WsResource(this.transport);
+    this.realtime = new RealtimeClient(this.config);
+  }
+  getRateLimitInfo() {
+    return this.transport.getRateLimitInfo();
+  }
+}
+export {
+  ApiError,
+  AuthenticationError,
+  ConfigurationError,
+  DEFAULT_BASE_URL,
+  DEFAULT_MAX_RETRIES,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_WS_URL,
+  DefaultLogger,
+  NetworkError,
+  ParseError,
+  PermissionError,
+  PiaClient,
+  PiaError,
+  RateLimitError,
+  RealtimeClient,
+  TimeoutError,
+  ValidationError,
+  redactSensitive,
+  resolveConfig
+};
+
+//# debugId=2A73CEA3E1247E3664756E2164756E21
+//# sourceMappingURL=index.js.map