polyedge 0.0.0-stage → 1.0.0

package/dist/index.cjs

@@ -0,0 +1,643 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AccountService: () => AccountService,
+  AnalyticsService: () => AnalyticsService,
+  PolyEdgeClient: () => PolyEdgeClient,
+  PolyEdgeStream: () => PolyEdgeStream,
+  StreamsService: () => StreamsService,
+  SubscriptionService: () => SubscriptionService
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/stream.ts
+var import_node_events = require("events");
+var PolyEdgeStream = class extends import_node_events.EventEmitter {
+  streamId;
+  apiKey;
+  streamBaseUrl;
+  heartbeatTimeoutMs;
+  initialBackoffMs;
+  maxBackoffMs;
+  lastEventId = null;
+  abortController = null;
+  watchdogTimer = null;
+  reconnectTimer = null;
+  reconnectAttempts = 0;
+  isDestroyed = false;
+  isConnecting = false;
+  // Queue for async iterator support
+  asyncQueue = [];
+  asyncResolvers = [];
+  constructor(streamId, options) {
+    super();
+    if (!streamId || typeof streamId !== "string") {
+      throw new Error("PolyEdgeStream: streamId must be a non-empty string");
+    }
+    if (!options.apiKey || typeof options.apiKey !== "string") {
+      throw new Error("PolyEdgeStream: apiKey must be a non-empty string");
+    }
+    this.streamId = streamId;
+    this.apiKey = options.apiKey;
+    this.streamBaseUrl = (options.streamBaseUrl || "https://stream.polyedge.dev").replace(/\/+$/, "");
+    this.heartbeatTimeoutMs = options.heartbeatTimeoutMs ?? 45e3;
+    this.initialBackoffMs = options.initialBackoffMs ?? 1e3;
+    this.maxBackoffMs = options.maxBackoffMs ?? 3e4;
+  }
+  getLastEventId() {
+    return this.lastEventId;
+  }
+  connect() {
+    if (this.isDestroyed || this.isConnecting) return;
+    this.isConnecting = true;
+    this.clearTimers();
+    this.abortController = new AbortController();
+    const currentSignal = this.abortController.signal;
+    const streamUrl = new URL(`${this.streamBaseUrl}/streams/${this.streamId}`);
+    if (this.lastEventId) {
+      streamUrl.searchParams.set("lastEventId", this.lastEventId);
+    }
+    const headers = {
+      Accept: "text/event-stream",
+      "X-PolyEdge-Key": this.apiKey,
+      "Cache-Control": "no-cache"
+    };
+    if (this.lastEventId) {
+      headers["Last-Event-ID"] = this.lastEventId;
+    }
+    this.startWatchdog();
+    (async () => {
+      try {
+        const response = await fetch(streamUrl.toString(), {
+          method: "GET",
+          headers,
+          signal: currentSignal
+        });
+        if (!response.ok) {
+          const errText = await response.text().catch(() => "");
+          const errMsg = `Stream connection failed with HTTP ${response.status}: ${errText}`;
+          const err = new Error(errMsg);
+          if ([400, 401, 403, 404].includes(response.status)) {
+            this.pushAsync({ err });
+            this.emit("error", err);
+            this.destroy("fatal_http_status");
+            return;
+          }
+          throw err;
+        }
+        if (!response.body) {
+          throw new Error("Response body is null, expected text/event-stream stream");
+        }
+        this.reconnectAttempts = 0;
+        this.isConnecting = false;
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder("utf-8");
+        let buffer = "";
+        while (!this.isDestroyed) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          this.resetWatchdog();
+          buffer += decoder.decode(value, { stream: true });
+          const blocks = buffer.split("\n\n");
+          buffer = blocks.pop() ?? "";
+          for (const block of blocks) {
+            this.parseBlock(block);
+          }
+        }
+        if (!this.isDestroyed) {
+          this.scheduleReconnect("stream_eos");
+        }
+      } catch (err) {
+        if (this.isDestroyed || currentSignal.aborted) return;
+        this.emit("error", err instanceof Error ? err : new Error(String(err)));
+        this.scheduleReconnect("network_error");
+      } finally {
+        this.isConnecting = false;
+      }
+    })();
+  }
+  parseBlock(block) {
+    const trimmed = block.trim();
+    if (!trimmed) return;
+    if (trimmed.startsWith(":")) {
+      this.emit("heartbeat");
+      return;
+    }
+    const lines = trimmed.split("\n");
+    let eventId = null;
+    let eventType = "message";
+    const dataLines = [];
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (line.startsWith(":")) {
+        continue;
+      } else if (line.startsWith("id:")) {
+        eventId = line.slice(3).trim();
+      } else if (line.startsWith("event:")) {
+        eventType = line.slice(6).trim();
+      } else if (line.startsWith("data:")) {
+        dataLines.push(rawLine.slice(rawLine.indexOf("data:") + 5).trimStart());
+      }
+    }
+    if (eventId) {
+      this.lastEventId = eventId;
+    }
+    if (eventType === "tx" && dataLines.length > 0) {
+      const payloadStr = dataLines.join("\n");
+      try {
+        const tx = JSON.parse(payloadStr);
+        this.pushAsync({ tx });
+        this.emit("tx", tx, this.lastEventId ?? "");
+      } catch (err) {
+        this.emit("error", new Error(`Failed to parse LiveTransaction JSON: ${String(err)}`));
+      }
+    }
+  }
+  startWatchdog() {
+    this.clearWatchdog();
+    this.watchdogTimer = setTimeout(() => {
+      this.emit("error", new Error(`SSE Watchdog timed out after ${this.heartbeatTimeoutMs}ms with no bytes/heartbeat received`));
+      this.abortController?.abort();
+      this.scheduleReconnect("watchdog_timeout");
+    }, this.heartbeatTimeoutMs);
+  }
+  resetWatchdog() {
+    if (!this.isDestroyed) {
+      this.startWatchdog();
+    }
+  }
+  clearWatchdog() {
+    if (this.watchdogTimer) {
+      clearTimeout(this.watchdogTimer);
+      this.watchdogTimer = null;
+    }
+  }
+  clearTimers() {
+    this.clearWatchdog();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  scheduleReconnect(reason) {
+    if (this.isDestroyed) return;
+    this.clearTimers();
+    this.isConnecting = false;
+    this.reconnectAttempts++;
+    const exponential = Math.min(
+      this.maxBackoffMs,
+      this.initialBackoffMs * Math.pow(2, this.reconnectAttempts - 1)
+    );
+    const jitter = exponential * (0.8 + Math.random() * 0.4);
+    const delayMs = Math.round(jitter);
+    this.emit("reconnect", this.reconnectAttempts, delayMs);
+    this.reconnectTimer = setTimeout(() => {
+      this.connect();
+    }, delayMs);
+  }
+  pushAsync(item) {
+    this.asyncQueue.push(item);
+    const resolver = this.asyncResolvers.shift();
+    if (resolver) resolver();
+  }
+  async *[Symbol.asyncIterator]() {
+    if (!this.isConnecting && !this.abortController && !this.isDestroyed) {
+      this.connect();
+    }
+    try {
+      while (!this.isDestroyed) {
+        while (this.asyncQueue.length > 0) {
+          const item = this.asyncQueue.shift();
+          if (item.err) throw item.err;
+          if (item.done) return;
+          if (item.tx) yield item.tx;
+        }
+        await new Promise((resolve) => {
+          this.asyncResolvers.push(resolve);
+        });
+      }
+    } finally {
+      this.destroy("async_iterator_break");
+    }
+  }
+  destroy(reason = "client_destroyed") {
+    if (this.isDestroyed) return;
+    this.isDestroyed = true;
+    this.isConnecting = false;
+    this.clearTimers();
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this.pushAsync({ done: true });
+    this.emit("close", reason);
+    this.removeAllListeners();
+  }
+};
+
+// src/client.ts
+var StreamsService = class {
+  request;
+  apiBaseUrl;
+  streamBaseUrl;
+  apiKey;
+  constructor(request, apiBaseUrl, streamBaseUrl, apiKey) {
+    this.request = request;
+    this.apiBaseUrl = apiBaseUrl;
+    this.streamBaseUrl = streamBaseUrl;
+    this.apiKey = apiKey;
+  }
+  /**
+   * Connect to real-time Server-Sent Events (SSE) order execution stream
+   * @param streamId Target stream ID
+   */
+  connect(streamId, options = {}) {
+    const s = new PolyEdgeStream(streamId, {
+      apiKey: this.apiKey,
+      streamBaseUrl: this.streamBaseUrl,
+      ...options
+    });
+    queueMicrotask(() => s.connect());
+    return s;
+  }
+  /**
+   * List User Streams
+   * Returns custom and managed real-time trade streams configured by the user.
+   * @returns Models.UserStreamsResponse
+   */
+  async list() {
+    return this.request(this.streamBaseUrl, `/streams`, { method: "GET" });
+  }
+  /**
+   * Create Filtered Order Stream
+   * Provisions a new custom real-time stream with optional address, tag, or series filters.
+   * @param req Request payload
+   * @returns Models.UserStreamResponse
+   */
+  async create(req) {
+    return this.request(this.streamBaseUrl, `/streams`, { method: "POST", body: JSON.stringify(req) });
+  }
+  /**
+   * Get Stream Metadata
+   * Fetches metadata, active sessions count, and filter configuration for a specific stream.
+   * @param id Stream unique ID
+   * @returns Models.UserStreamResponse
+   */
+  async get(id) {
+    return this.request(this.streamBaseUrl, `/streams/${id}/meta`, { method: "GET" });
+  }
+  /**
+   * Delete Stream
+   * Permanently removes a stream and gracefully disconnects all connected listener sessions.
+   * @param id Stream unique ID
+   * @returns Models.DeleteStreamResponse
+   */
+  async delete(id) {
+    return this.request(this.streamBaseUrl, `/streams/${id}`, { method: "DELETE" });
+  }
+  /**
+   * Update Stream Metadata
+   * Updates operational attributes of the stream, such as nickname or enabled/disabled status.
+   * @param id Stream unique ID
+   * @param req Request payload
+   * @returns Models.UserStreamResponse
+   */
+  async updateMetadata(id, req) {
+    return this.request(this.streamBaseUrl, `/streams/${id}/meta`, { method: "PUT", body: JSON.stringify(req) });
+  }
+  /**
+   * Update Stream Filter Subscription
+   * Dynamically mutates monitored wallet addresses, market tags, or series slugs without disconnecting SSE clients.
+   * @param id Stream unique ID
+   * @param req Request payload
+   * @returns Models.UserStreamResponse
+   */
+  async updateSubscription(id, req) {
+    return this.request(this.streamBaseUrl, `/streams/${id}/subscription`, { method: "PUT", body: JSON.stringify(req) });
+  }
+  /**
+   * List All User Active Sessions
+   * Returns all currently connected active SSE listeners for this account.
+   * @returns Models.UserActiveSessionsResponse
+   */
+  async getActiveSessions() {
+    return this.request(this.streamBaseUrl, `/sessions`, { method: "GET" });
+  }
+  /**
+   * List User Stream Session History
+   * Returns historical SSE connection logs including duration and pushed transactions count.
+   * @param params.limit Max records to return
+   * @param params.offset Pagination offset
+   * @returns Models.UserSessionHistoryResponse
+   */
+  async getSessionHistory(params = {}) {
+    const query = new URLSearchParams();
+    if (params.limit !== void 0) query.set("limit", String(params.limit));
+    if (params.offset !== void 0) query.set("offset", String(params.offset));
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.request(this.streamBaseUrl, `/sessions/history${qs}`, { method: "GET" });
+  }
+};
+var AnalyticsService = class {
+  request;
+  apiBaseUrl;
+  streamBaseUrl;
+  apiKey;
+  constructor(request, apiBaseUrl, streamBaseUrl, apiKey) {
+    this.request = request;
+    this.apiBaseUrl = apiBaseUrl;
+    this.streamBaseUrl = streamBaseUrl;
+    this.apiKey = apiKey;
+  }
+  /**
+   * 60-Day Trader Deposit Analytics
+   * Returns 60-day aggregated deposit summary and individual transaction breakdown for top traders.
+   * @param params.limit Max records to return
+   * @param params.offset Pagination offset
+   * @returns Models.DepositQueryResult
+   */
+  async getDeposits(params = {}) {
+    const query = new URLSearchParams();
+    if (params.limit !== void 0) query.set("limit", String(params.limit));
+    if (params.offset !== void 0) query.set("offset", String(params.offset));
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.request(this.apiBaseUrl, `/v2/analytics/deposits${qs}`, { method: "GET" });
+  }
+  /**
+   * Top Traders PnL Leaderboard
+   * Queries ranked traders across timeframes with PnL, volume, win rate, and performance metrics.
+   * @param params.limit Max traders to return
+   * @param params.offset Pagination offset
+   * @returns Models.LeaderboardResponse
+   */
+  async getLeaderboard(params = {}) {
+    const query = new URLSearchParams();
+    if (params.limit !== void 0) query.set("limit", String(params.limit));
+    if (params.offset !== void 0) query.set("offset", String(params.offset));
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.request(this.apiBaseUrl, `/v2/analytics/leaderboard${qs}`, { method: "GET" });
+  }
+  /**
+   * Get Prediction Market Detail
+   * Fetches standardized market metadata matching on-chain condition IDs and NegRisk parameters.
+   * @param id Market numeric ID or condition ID
+   * @returns Models.MarketDetailResponse
+   */
+  async getMarket(id) {
+    return this.request(this.apiBaseUrl, `/v2/markets/${id}`, { method: "GET" });
+  }
+  /**
+   * Get Trader Intelligence Profile
+   * Fetches trader identity dossier, pUSD balance, total PnL, win rates, and ranking metrics.
+   * @param address Trader Polygon/Ethereum wallet address
+   * @returns Models.TraderProfileResponse
+   */
+  async getTrader(address) {
+    return this.request(this.apiBaseUrl, `/v2/traders/${address}`, { method: "GET" });
+  }
+  /**
+   * Get Hourly PnL Equity Curve
+   * Provides 1-hour bucketed historical equity curves and trade metrics for a specific trader.
+   * @param address Trader Polygon/Ethereum wallet address
+   * @returns Models.TraderHourlyStatsResponse
+   */
+  async getTraderHourlyStats(address) {
+    return this.request(this.apiBaseUrl, `/v2/traders/${address}/hourly_stats`, { method: "GET" });
+  }
+  /**
+   * Get Trader Market Participation History
+   * Queries resolved and active prediction markets traded by the specified wallet address.
+   * @param address Trader Polygon/Ethereum wallet address
+   * @param params.limit Max markets to return
+   * @param params.offset Pagination offset
+   * @returns Models.TraderHistoryResponse
+   */
+  async getTraderMarkets(address, params = {}) {
+    const query = new URLSearchParams();
+    if (params.limit !== void 0) query.set("limit", String(params.limit));
+    if (params.offset !== void 0) query.set("offset", String(params.offset));
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.request(this.apiBaseUrl, `/v2/traders/${address}/markets${qs}`, { method: "GET" });
+  }
+  /**
+   * Get Trader Orders in Market
+   * Retrieves granular fill events, side, price, and token outcomes for a trader in a given market.
+   * @param address Trader wallet address
+   * @param id Market numeric ID
+   * @param params.limit Max orders to return
+   * @param params.offset Pagination offset
+   * @returns Models.UserOrdersResponse
+   */
+  async getTraderMarketOrders(address, id, params = {}) {
+    const query = new URLSearchParams();
+    if (params.limit !== void 0) query.set("limit", String(params.limit));
+    if (params.offset !== void 0) query.set("offset", String(params.offset));
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.request(this.apiBaseUrl, `/v2/traders/${address}/markets/${id}/orders${qs}`, { method: "GET" });
+  }
+};
+var AccountService = class {
+  request;
+  apiBaseUrl;
+  streamBaseUrl;
+  apiKey;
+  constructor(request, apiBaseUrl, streamBaseUrl, apiKey) {
+    this.request = request;
+    this.apiBaseUrl = apiBaseUrl;
+    this.streamBaseUrl = streamBaseUrl;
+    this.apiKey = apiKey;
+  }
+  /**
+   * Get Current Profile
+   * Retrieves the authenticated user profile, tier subscription status, and available USDC balance.
+   * @returns Models.UserProfile
+   */
+  async getProfile() {
+    return this.request(this.apiBaseUrl, `/v2/user/me`, { method: "GET" });
+  }
+  /**
+   * List API Keys
+   * Lists all active and revoked API keys issued to the authenticated account.
+   * @returns Models.UserKeysResponse
+   */
+  async listKeys() {
+    return this.request(this.apiBaseUrl, `/v2/user/keys`, { method: "GET" });
+  }
+  /**
+   * Create API Key
+   * Generates a new authenticated API key token with optional memo label.
+   * @param req Request payload
+   * @returns Models.UserAPIKey
+   */
+  async createKey(req) {
+    return this.request(this.apiBaseUrl, `/v2/user/keys`, { method: "POST", body: JSON.stringify(req) });
+  }
+  /**
+   * Update API Key
+   * Modifies label memo or operational status of an existing API key.
+   * @param key API key string
+   * @param req Request payload
+   * @returns Models.UserAPIKey
+   */
+  async updateKey(key, req) {
+    return this.request(this.apiBaseUrl, `/v2/user/keys/${key}`, { method: "PATCH", body: JSON.stringify(req) });
+  }
+  /**
+   * Revoke API Key
+   * Permanently revokes and deactivates an API key token.
+   * @param key API key string
+   * @returns Models.DeleteKeyResponse
+   */
+  async deleteKey(key) {
+    return this.request(this.apiBaseUrl, `/v2/user/keys/${key}`, { method: "DELETE" });
+  }
+  /**
+   * List User Balance Ledger
+   * Lists chronological ledger entries (subscription billing charges, deposits, withdrawals).
+   * @param params.limit Max entries to return
+   * @param params.offset Pagination offset
+   * @returns Models.UserLedgerResponse
+   */
+  async getLedger(params = {}) {
+    const query = new URLSearchParams();
+    if (params.limit !== void 0) query.set("limit", String(params.limit));
+    if (params.offset !== void 0) query.set("offset", String(params.offset));
+    const qs = query.toString() ? `?${query.toString()}` : "";
+    return this.request(this.apiBaseUrl, `/v2/user/ledger${qs}`, { method: "GET" });
+  }
+  /**
+   * Get Account Telemetry & Limits
+   * Provides live usage statistics, quota limits, and remaining streaming bandwidth.
+   * @returns Models.UserTelemetryResponse
+   */
+  async getTelemetry() {
+    return this.request(this.apiBaseUrl, `/v2/user/telemetry`, { method: "GET" });
+  }
+  /**
+   * Request Balance Withdrawal
+   * Submits a request to withdraw unspent USDC balance to a designated Polygon address.
+   * @param req Request payload
+   * @returns Models.UserWithdrawResponse
+   */
+  async withdraw(req) {
+    return this.request(this.apiBaseUrl, `/v2/user/withdraw`, { method: "POST", body: JSON.stringify(req) });
+  }
+};
+var SubscriptionService = class {
+  request;
+  apiBaseUrl;
+  streamBaseUrl;
+  apiKey;
+  constructor(request, apiBaseUrl, streamBaseUrl, apiKey) {
+    this.request = request;
+    this.apiBaseUrl = apiBaseUrl;
+    this.streamBaseUrl = streamBaseUrl;
+    this.apiKey = apiKey;
+  }
+  /**
+   * List Public Tiers Catalog
+   * Returns plan tiers (Free, Starter, Pro, Growth, Whale) with limits and pricing details.
+   * @returns Models.Tier[]
+   */
+  async listTiers() {
+    return this.request(this.apiBaseUrl, `/v2/tiers`, { method: "GET" });
+  }
+  /**
+   * Get Subscription Quote
+   * Calculates prorated billing amounts for subscribing to or upgrading a tier plan.
+   * @param req Request payload
+   * @returns Models.QuoteSubscriptionResponse
+   */
+  async getQuote(req) {
+    return this.request(this.apiBaseUrl, `/v2/user/subscribe/quote`, { method: "POST", body: JSON.stringify(req) });
+  }
+  /**
+   * Purchase / Upgrade Tier Subscription
+   * Executes purchase, renewal, or upgrade of an active subscription tier plan.
+   * @param req Request payload
+   * @returns Models.SubscribeResponse
+   */
+  async subscribe(req) {
+    return this.request(this.apiBaseUrl, `/v2/user/subscribe`, { method: "POST", body: JSON.stringify(req) });
+  }
+  /**
+   * Validate Promo Code
+   * Verifies validity, discount percentage, and applicable plans for a promotion coupon code.
+   * @param req Request payload
+   * @returns Models.ValidatePromoCodeResponse
+   */
+  async validatePromoCode(req) {
+    return this.request(this.apiBaseUrl, `/v2/user/promo-codes/validate`, { method: "POST", body: JSON.stringify(req) });
+  }
+};
+var PolyEdgeClient = class {
+  apiKey;
+  apiBaseUrl;
+  streamBaseUrl;
+  /** Streams Service: Real-time SSE trade streaming & filters */
+  streams;
+  /** Analytics Service: Leaderboard, trader intelligence, markets */
+  analytics;
+  /** Account Service: Profile, keys, ledger, telemetry */
+  account;
+  /** Subscription Service: Plan tiers, quotes, checkout */
+  subscription;
+  constructor(options) {
+    if (!options.apiKey) throw new Error("PolyEdgeClient: apiKey is required");
+    this.apiKey = options.apiKey;
+    this.apiBaseUrl = (options.apiBaseUrl || "https://api.polyedge.dev").replace(/\/+$/, "");
+    this.streamBaseUrl = (options.streamBaseUrl || "https://stream.polyedge.dev").replace(/\/+$/, "");
+    const req = this.request.bind(this);
+    this.streams = new StreamsService(req, this.apiBaseUrl, this.streamBaseUrl, this.apiKey);
+    this.analytics = new AnalyticsService(req, this.apiBaseUrl, this.streamBaseUrl, this.apiKey);
+    this.account = new AccountService(req, this.apiBaseUrl, this.streamBaseUrl, this.apiKey);
+    this.subscription = new SubscriptionService(req, this.apiBaseUrl, this.streamBaseUrl, this.apiKey);
+  }
+  async request(baseUrl, endpoint, options = {}) {
+    const url = `${baseUrl}${endpoint}`;
+    const headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "X-PolyEdge-Key": this.apiKey,
+      ...options.headers
+    };
+    const res = await fetch(url, { ...options, headers });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`PolyEdge API Error [${res.status}]: ${body}`);
+    }
+    return res.json();
+  }
+  /** Direct helper to create SSE order stream */
+  stream(streamId, options = {}) {
+    return this.streams.connect(streamId, options);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountService,
+  AnalyticsService,
+  PolyEdgeClient,
+  PolyEdgeStream,
+  StreamsService,
+  SubscriptionService
+});