@iteradian-rpc/sdk 1.0.1

package/dist/index.mjs

@@ -0,0 +1,770 @@
+// src/http.ts
+var IteradianError = class extends Error {
+  constructor(message, statusCode, error, rpc) {
+    super(message);
+    this.name = "IteradianError";
+    this.statusCode = statusCode;
+    this.error = error;
+    this.rpcCode = rpc?.code;
+    this.retryAfter = rpc?.retryAfter;
+    this.data = rpc?.data;
+  }
+  /** True when the request failed because the subscription is out of allowance. */
+  get isQuotaExhausted() {
+    return this.rpcCode === -32006 || this.rpcCode === -32007;
+  }
+  /** True when the request was throttled and is worth retrying. */
+  get isRateLimited() {
+    return this.rpcCode === -32005;
+  }
+};
+var NON_IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
+  "eth_sendRawTransaction",
+  "eth_sendTransaction",
+  "eth_submitWork",
+  "author_submitExtrinsic",
+  "author_submitAndWatchExtrinsic",
+  "sendTransaction",
+  "requestAirdrop",
+  "broadcast_tx_sync",
+  "broadcast_tx_async",
+  "broadcast_tx_commit"
+]);
+var MAX_RETRY_DELAY_MS = 3e4;
+function isReplayableBody(body) {
+  const one = (r) => {
+    const method = r?.method;
+    return typeof method === "string" && NON_IDEMPOTENT_METHODS.has(method);
+  };
+  if (Array.isArray(body)) return !body.some(one);
+  if (body && typeof body === "object") return !one(body);
+  return true;
+}
+var HttpClient = class {
+  constructor(config) {
+    this.baseUrl = (config.baseUrl || "https://api.iteradian.com/api/v1").replace(/\/$/, "");
+    this.gatewayUrl = (config.gatewayUrl || "https://rpc.iteradian.com").replace(/\/$/, "");
+    this.accessToken = config.accessToken;
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout || 3e4;
+    this.customHeaders = config.headers || {};
+    this.retry = config.retry !== false;
+    this.maxRetries = config.maxRetries || 3;
+  }
+  setAccessToken(token) {
+    this.accessToken = token;
+  }
+  clearAccessToken() {
+    this.accessToken = void 0;
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...this.customHeaders
+    };
+    if (this.accessToken) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    }
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    return headers;
+  }
+  async request(method, path, body, attempt = 1, base, signal) {
+    const url = `${base ?? this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    const onAbort = () => controller.abort();
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) controller.abort();
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: this.buildHeaders(),
+        body: body != null ? JSON.stringify(body) : void 0,
+        signal: controller.signal,
+        // Neither host redirects. Following one would hand `X-API-Key` to
+        // whatever origin the redirect names: Node's fetch strips
+        // `Authorization` across origins but keeps custom headers.
+        redirect: "manual"
+      });
+      if (response.status >= 300 && response.status < 400) {
+        clearTimeout(timer);
+        throw new IteradianError(
+          `Unexpected redirect (${response.status}) from ${url}. The Iteradian API does not redirect; refusing to resend credentials to another origin.`,
+          response.status,
+          "UNEXPECTED_REDIRECT"
+        );
+      }
+      clearTimeout(timer);
+      if (!response.ok) {
+        let errorBody;
+        try {
+          errorBody = await response.json();
+        } catch {
+          errorBody = {
+            message: response.statusText || "Unknown error",
+            statusCode: response.status
+          };
+        }
+        const rpc = errorBody?.error;
+        const rpcCode = typeof rpc?.code === "number" ? rpc.code : void 0;
+        const retryAfter = typeof rpc?.data?.retryAfter === "number" ? rpc.data.retryAfter : void 0;
+        const worthRetrying = response.status >= 500 || response.status === 429 && rpcCode !== -32006 && rpcCode !== -32007;
+        if (this.retry && attempt < this.maxRetries && worthRetrying && isReplayableBody(body) && !controller.signal.aborted) {
+          const backoff = Math.min(1e3 * 2 ** (attempt - 1), 1e4);
+          const delay = Math.min(
+            retryAfter != null ? retryAfter * 1e3 : backoff,
+            MAX_RETRY_DELAY_MS
+          );
+          await new Promise((r) => setTimeout(r, delay));
+          return this.request(method, path, body, attempt + 1, base, signal);
+        }
+        throw new IteradianError(
+          rpc?.message || errorBody.message || response.statusText,
+          errorBody.statusCode || response.status,
+          errorBody.error,
+          { code: rpcCode, retryAfter, data: rpc?.data }
+        );
+      }
+      if (response.status === 204 || response.status === 205) {
+        return void 0;
+      }
+      const text = await response.text();
+      if (text === "") {
+        throw new IteradianError(
+          `Empty response body from ${method} ${path}`,
+          response.status,
+          "EMPTY_RESPONSE"
+        );
+      }
+      try {
+        return JSON.parse(text);
+      } catch (err) {
+        throw new IteradianError(
+          `Could not decode the response body: ${err.message}`,
+          response.status,
+          "DECODE_ERROR"
+        );
+      }
+    } catch (err) {
+      clearTimeout(timer);
+      if (err instanceof IteradianError) throw err;
+      if (err.name === "AbortError") {
+        if (signal?.aborted) {
+          throw new IteradianError("Request cancelled", 0, "CANCELLED");
+        }
+        throw new IteradianError("Request timed out", 408, "TIMEOUT");
+      }
+      throw new IteradianError(err.message, 0, "NETWORK_ERROR");
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  get(path) {
+    return this.request("GET", path);
+  }
+  post(path, body) {
+    return this.request("POST", path, body);
+  }
+  put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  /**
+   * Call the RPC gateway rather than the control plane.
+   *
+   * Separate base URL because the gateway is not under `/api/v1`: it serves
+   * `POST /rpc/v1/{network}` at the host root.
+   */
+  gateway(path, body, signal) {
+    return this.request("POST", path, body, 1, this.gatewayUrl, signal);
+  }
+  gatewayGet(path, signal) {
+    return this.request("GET", path, void 0, 1, this.gatewayUrl, signal);
+  }
+  delete(path, body) {
+    return this.request("DELETE", path, body);
+  }
+};
+
+// src/resources/auth.ts
+var AuthResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Register a new user account */
+  register(data) {
+    return this.http.post("/auth/register", data);
+  }
+  /** Login with email/password (optionally with 2FA code) */
+  async login(data) {
+    const tokens = await this.http.post("/auth/login", data);
+    this.http.setAccessToken(tokens.accessToken);
+    return tokens;
+  }
+  /** Logout current session */
+  logout() {
+    return this.http.post("/auth/logout");
+  }
+  /** Refresh the access token */
+  async refresh(refreshToken) {
+    const tokens = await this.http.post("/auth/refresh", {
+      refreshToken
+    });
+    this.http.setAccessToken(tokens.accessToken);
+    return tokens;
+  }
+  /** Verify email with token */
+  verifyEmail(token) {
+    return this.http.post("/auth/verify-email", { token });
+  }
+  /** Resend email verification */
+  resendVerification(email) {
+    return this.http.post("/auth/resend-verification", { email });
+  }
+  /** Request password reset email */
+  forgotPassword(email) {
+    return this.http.post("/auth/forgot-password", { email });
+  }
+  /** Reset password with token */
+  resetPassword(token, newPassword) {
+    return this.http.post("/auth/reset-password", { token, newPassword });
+  }
+  /** Request a magic login link */
+  requestMagicLink(email) {
+    return this.http.post("/auth/magic-link", { email });
+  }
+  /** Login via magic link token */
+  async loginWithMagicLink(token) {
+    const tokens = await this.http.post("/auth/magic-login", {
+      token
+    });
+    this.http.setAccessToken(tokens.accessToken);
+    return tokens;
+  }
+  /** Enable 2FA – returns QR code image and secret */
+  enable2FA(password) {
+    return this.http.post("/auth/2fa/enable", { password });
+  }
+  /** Verify 2FA setup with code from authenticator app */
+  verify2FA(code) {
+    return this.http.post("/auth/2fa/verify", { code });
+  }
+  /** Disable 2FA */
+  disable2FA(password, code) {
+    return this.http.post("/auth/2fa/disable", { password, code });
+  }
+  /** Regenerate backup codes */
+  regenerateBackupCodes(password) {
+    return this.http.post("/auth/2fa/backup-codes", { password });
+  }
+};
+
+// src/resources/organizations.ts
+var OrganizationsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** List organizations the current user belongs to */
+  list() {
+    return this.http.get("/orgs");
+  }
+  /** Create a new organization */
+  create(data) {
+    return this.http.post("/orgs", data);
+  }
+  /** Get organization details */
+  get(orgId) {
+    return this.http.get(`/orgs/${orgId}`);
+  }
+  /** Update an organization */
+  update(orgId, data) {
+    return this.http.put(`/orgs/${orgId}`, data);
+  }
+  /** Delete an organization */
+  delete(orgId) {
+    return this.http.delete(`/orgs/${orgId}`);
+  }
+  /** Leave an organization */
+  leave(orgId) {
+    return this.http.post(`/orgs/${orgId}/leave`);
+  }
+  /** List organization members */
+  listMembers(orgId) {
+    return this.http.get(`/orgs/${orgId}/members`);
+  }
+  /** Invite a member to the organization */
+  inviteMember(orgId, data) {
+    return this.http.post(`/orgs/${orgId}/members`, data);
+  }
+  /** Update a member's role */
+  updateMemberRole(orgId, memberId, role) {
+    return this.http.put(`/orgs/${orgId}/members/${memberId}`, { role });
+  }
+  /** Remove a member from the organization */
+  removeMember(orgId, memberId) {
+    return this.http.delete(`/orgs/${orgId}/members/${memberId}`);
+  }
+  /** Get current user's permissions in the organization */
+  getMyPermissions(orgId) {
+    return this.http.get(`/orgs/${orgId}/permissions`);
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeysResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** List all API keys for an organization */
+  list(orgId) {
+    return this.http.get(`/orgs/${orgId}/keys`);
+  }
+  /** Get a specific API key */
+  get(orgId, keyId) {
+    return this.http.get(`/orgs/${orgId}/keys/${keyId}`);
+  }
+  /** Create a new API key (returns the full key only once) */
+  create(orgId, data) {
+    return this.http.post(`/orgs/${orgId}/keys`, data);
+  }
+  /** Update an API key */
+  update(orgId, keyId, data) {
+    return this.http.put(`/orgs/${orgId}/keys/${keyId}`, data);
+  }
+  /** Revoke (delete) an API key */
+  revoke(orgId, keyId) {
+    return this.http.delete(`/orgs/${orgId}/keys/${keyId}`);
+  }
+  /** Rotate an API key (revoke old, create new) */
+  rotate(orgId, keyId) {
+    return this.http.post(`/orgs/${orgId}/keys/${keyId}/rotate`);
+  }
+  /** Get analytics for an API key */
+  getAnalytics(orgId, keyId, timeRange = "7d") {
+    return this.http.get(
+      `/orgs/${orgId}/keys/${keyId}/analytics?timeRange=${timeRange}`
+    );
+  }
+};
+
+// src/resources/endpoints.ts
+var EndpointsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  // ==================== Networks ====================
+  /** List all available networks */
+  getNetworks() {
+    return this.http.get("/networks");
+  }
+  /** Get a specific network */
+  getNetwork(networkId) {
+    return this.http.get(`/networks/${networkId}`);
+  }
+  // ==================== Endpoints CRUD ====================
+  /** List all endpoints for an organization */
+  list(orgId) {
+    return this.http.get(`/orgs/${orgId}/endpoints`);
+  }
+  /** Get a specific endpoint */
+  get(orgId, endpointId) {
+    return this.http.get(`/orgs/${orgId}/endpoints/${endpointId}`);
+  }
+  /** Create a new endpoint */
+  create(orgId, data) {
+    return this.http.post(`/orgs/${orgId}/endpoints`, data);
+  }
+  /** Update an endpoint */
+  update(orgId, endpointId, data) {
+    return this.http.put(`/orgs/${orgId}/endpoints/${endpointId}`, data);
+  }
+  /** Delete an endpoint */
+  delete(orgId, endpointId) {
+    return this.http.delete(`/orgs/${orgId}/endpoints/${endpointId}`);
+  }
+  // ==================== Status Management ====================
+  /** Pause an endpoint */
+  pause(orgId, endpointId) {
+    return this.http.post(`/orgs/${orgId}/endpoints/${endpointId}/pause`);
+  }
+  /** Resume an endpoint */
+  resume(orgId, endpointId) {
+    return this.http.post(`/orgs/${orgId}/endpoints/${endpointId}/resume`);
+  }
+  // ==================== Health & Metrics ====================
+  /** Trigger a health check */
+  checkHealth(orgId, endpointId) {
+    return this.http.post(
+      `/orgs/${orgId}/endpoints/${endpointId}/health-check`
+    );
+  }
+  /** Get endpoint health summary */
+  getHealthOverview(orgId) {
+    return this.http.get(`/orgs/${orgId}/endpoints/summary`);
+  }
+  /** Get endpoint metrics */
+  getMetrics(orgId, endpointId, from, to) {
+    const params = new URLSearchParams();
+    if (from) params.append("from", from);
+    if (to) params.append("to", to);
+    return this.http.get(
+      `/orgs/${orgId}/endpoints/${endpointId}/metrics?${params.toString()}`
+    );
+  }
+  /** Update endpoint priorities */
+  updatePriorities(orgId, priorities) {
+    return this.http.patch(`/orgs/${orgId}/endpoints/priorities`, {
+      priorities
+    });
+  }
+};
+
+// src/resources/usage.ts
+var UsageResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Get usage analytics for a date range */
+  get(orgId, from, to) {
+    return this.http.get(`/orgs/${orgId}/usage?from=${from}&to=${to}`);
+  }
+  /** Get usage summary */
+  getSummary(orgId) {
+    return this.http.get(`/orgs/${orgId}/usage/summary`);
+  }
+};
+
+// src/resources/dashboard.ts
+var DashboardResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Get full dashboard data */
+  get(orgId, period) {
+    const params = period ? `?period=${period}` : "";
+    return this.http.get(`/orgs/${orgId}/dashboard${params}`);
+  }
+  /** Get system health overview */
+  getHealth(orgId) {
+    return this.http.get(`/orgs/${orgId}/dashboard/health`);
+  }
+  /** Get quick stats */
+  getQuickStats(orgId, period) {
+    const params = period ? `?period=${period}` : "";
+    return this.http.get(`/orgs/${orgId}/dashboard/quick-stats${params}`);
+  }
+  /** Get request rate time series */
+  getRequestRate(orgId, period) {
+    const params = period ? `?period=${period}` : "";
+    return this.http.get(`/orgs/${orgId}/dashboard/request-rate${params}`);
+  }
+  /** Get error rate time series */
+  getErrorRate(orgId, period) {
+    const params = period ? `?period=${period}` : "";
+    return this.http.get(`/orgs/${orgId}/dashboard/error-rate${params}`);
+  }
+  /** Get latency metrics */
+  getLatency(orgId, period) {
+    const params = period ? `?period=${period}` : "";
+    return this.http.get(`/orgs/${orgId}/dashboard/latency${params}`);
+  }
+  /** Get performance metrics */
+  getPerformance(orgId) {
+    return this.http.get(`/orgs/${orgId}/dashboard/performance`);
+  }
+};
+
+// src/resources/alerts.ts
+var AlertsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  // ==================== Alerts ====================
+  /** List alerts for an organization */
+  list(orgId) {
+    return this.http.get(`/orgs/${orgId}/alerts`);
+  }
+  /** Acknowledge an alert */
+  acknowledge(orgId, alertId) {
+    return this.http.post(`/orgs/${orgId}/alerts/${alertId}/acknowledge`);
+  }
+  /** Resolve an alert */
+  resolve(orgId, alertId) {
+    return this.http.post(`/orgs/${orgId}/alerts/${alertId}/resolve`);
+  }
+  /** Evaluate all alert rules now */
+  evaluate(orgId) {
+    return this.http.post(`/orgs/${orgId}/alerts/evaluate`);
+  }
+  // ==================== Alert Rules ====================
+  /** List alert rules */
+  listRules(orgId) {
+    return this.http.get(`/orgs/${orgId}/alerts/rules`);
+  }
+  /** Create a new alert rule */
+  createRule(orgId, data) {
+    return this.http.post(`/orgs/${orgId}/alerts/rules`, data);
+  }
+  /** Get a specific alert rule */
+  getRule(orgId, ruleId) {
+    return this.http.get(`/orgs/${orgId}/alerts/rules/${ruleId}`);
+  }
+  /** Update an alert rule */
+  updateRule(orgId, ruleId, data) {
+    return this.http.put(`/orgs/${orgId}/alerts/rules/${ruleId}`, data);
+  }
+  /** Delete an alert rule */
+  deleteRule(orgId, ruleId) {
+    return this.http.delete(`/orgs/${orgId}/alerts/rules/${ruleId}`);
+  }
+  /** Toggle an alert rule on/off */
+  toggleRule(orgId, ruleId) {
+    return this.http.post(`/orgs/${orgId}/alerts/rules/${ruleId}/toggle`);
+  }
+  /** Seed default alert rules */
+  seedDefaults(orgId) {
+    return this.http.post(`/orgs/${orgId}/alerts/rules/seed-defaults`);
+  }
+  // ==================== Alert Channels ====================
+  /** List notification channels */
+  listChannels(orgId) {
+    return this.http.get(`/orgs/${orgId}/alerts/channels`);
+  }
+  /** Create a notification channel */
+  createChannel(orgId, data) {
+    return this.http.post(`/orgs/${orgId}/alerts/channels`, data);
+  }
+  /** Get a specific channel */
+  getChannel(orgId, channelId) {
+    return this.http.get(`/orgs/${orgId}/alerts/channels/${channelId}`);
+  }
+  /** Update a notification channel */
+  updateChannel(orgId, channelId, data) {
+    return this.http.put(`/orgs/${orgId}/alerts/channels/${channelId}`, data);
+  }
+  /** Delete a notification channel */
+  deleteChannel(orgId, channelId) {
+    return this.http.delete(`/orgs/${orgId}/alerts/channels/${channelId}`);
+  }
+  /** Test a notification channel */
+  testChannel(orgId, channelId) {
+    return this.http.post(`/orgs/${orgId}/alerts/channels/${channelId}/test`);
+  }
+};
+
+// src/resources/logs.ts
+var LogsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Query request logs with filters and pagination */
+  query(orgId, params) {
+    const searchParams = new URLSearchParams();
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null && value !== "") {
+          searchParams.append(key, String(value));
+        }
+      }
+    }
+    const qs = searchParams.toString();
+    return this.http.get(`/orgs/${orgId}/logs${qs ? `?${qs}` : ""}`);
+  }
+  /** Get a single log entry */
+  get(orgId, logId) {
+    return this.http.get(`/orgs/${orgId}/logs/${logId}`);
+  }
+  /** Get log statistics */
+  getStats(orgId) {
+    return this.http.get(`/orgs/${orgId}/logs/stats`);
+  }
+  /** Get available filter options */
+  getFilterOptions(orgId) {
+    return this.http.get(`/orgs/${orgId}/logs/filters`);
+  }
+};
+
+// src/resources/subscriptions.ts
+var SubscriptionsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Get current subscription */
+  get(orgId) {
+    return this.http.get(`/orgs/${orgId}/subscription`);
+  }
+  /** Change subscription plan */
+  changePlan(orgId, planId) {
+    return this.http.put(`/orgs/${orgId}/subscription/plan`, { planId });
+  }
+  /** Cancel subscription */
+  cancel(orgId) {
+    return this.http.post(`/orgs/${orgId}/subscription/cancel`);
+  }
+  /** Reactivate a cancelled subscription */
+  reactivate(orgId) {
+    return this.http.post(`/orgs/${orgId}/subscription/reactivate`);
+  }
+  /** Get invoices */
+  getInvoices(orgId, limit) {
+    const qs = limit ? `?limit=${limit}` : "";
+    return this.http.get(`/orgs/${orgId}/subscription/invoices${qs}`);
+  }
+};
+
+// src/resources/plans.ts
+var PlansResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** List all available plans */
+  list() {
+    return this.http.get("/plans");
+  }
+  /** Get a specific plan */
+  get(planId) {
+    return this.http.get(`/plans/${planId}`);
+  }
+};
+
+// src/resources/support.ts
+var SupportResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Create a support ticket */
+  createTicket(orgId, data) {
+    return this.http.post(`/orgs/${orgId}/support/tickets`, data);
+  }
+  /** List support tickets */
+  listTickets(orgId) {
+    return this.http.get(`/orgs/${orgId}/support/tickets`);
+  }
+  /** Get ticket statistics */
+  getStats(orgId) {
+    return this.http.get(`/orgs/${orgId}/support/tickets/stats`);
+  }
+  /** Get a specific ticket */
+  getTicket(orgId, ticketId) {
+    return this.http.get(`/orgs/${orgId}/support/tickets/${ticketId}`);
+  }
+  /** Add a message to a ticket */
+  addMessage(orgId, ticketId, content) {
+    return this.http.post(
+      `/orgs/${orgId}/support/tickets/${ticketId}/messages`,
+      { body: content }
+    );
+  }
+  /** Update ticket status */
+  updateStatus(orgId, ticketId, status) {
+    return this.http.put(`/orgs/${orgId}/support/tickets/${ticketId}/status`, {
+      status
+    });
+  }
+};
+
+// src/resources/rpc.ts
+var RpcResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Send a JSON-RPC 2.0 request to the specified network via the Iteradian gateway.
+   *
+   * @example
+   * ```ts
+   * const result = await client.rpc.call('eth-mainnet', {
+   *   jsonrpc: '2.0',
+   *   method: 'eth_blockNumber',
+   *   params: [],
+   *   id: 1,
+   * });
+   * ```
+   */
+  call(network, request, options) {
+    return this.http.gateway(
+      `/rpc/v1/${encodeURIComponent(network)}`,
+      request,
+      options?.signal
+    );
+  }
+  /**
+   * Send a batch of JSON-RPC 2.0 requests to the specified network.
+   *
+   * A batch of N calls costs N against both your per-second rate limit and
+   * your monthly request quota — it is a transport optimisation, not a
+   * billing one.
+   *
+   * @example
+   * ```ts
+   * const results = await client.rpc.batch('eth-mainnet', [
+   *   { jsonrpc: '2.0', method: 'eth_blockNumber', params: [], id: 1 },
+   *   { jsonrpc: '2.0', method: 'net_peerCount', params: [], id: 2 },
+   * ]);
+   * ```
+   */
+  batch(network, requests, options) {
+    return this.http.gateway(
+      `/rpc/v1/${encodeURIComponent(network)}`,
+      requests,
+      options?.signal
+    );
+  }
+  /**
+   * List the networks the gateway can currently route to.
+   *
+   * Only networks with at least one healthy node are advertised.
+   */
+  networks() {
+    return this.http.gatewayGet("/rpc/v1/networks");
+  }
+};
+
+// src/client.ts
+var IteradianClient = class {
+  constructor(config = {}) {
+    this.http = new HttpClient(config);
+    this.auth = new AuthResource(this.http);
+    this.organizations = new OrganizationsResource(this.http);
+    this.apiKeys = new ApiKeysResource(this.http);
+    this.endpoints = new EndpointsResource(this.http);
+    this.usage = new UsageResource(this.http);
+    this.dashboard = new DashboardResource(this.http);
+    this.alerts = new AlertsResource(this.http);
+    this.logs = new LogsResource(this.http);
+    this.subscriptions = new SubscriptionsResource(this.http);
+    this.plans = new PlansResource(this.http);
+    this.support = new SupportResource(this.http);
+    this.rpc = new RpcResource(this.http);
+  }
+  /** Set the access token for all subsequent requests */
+  setAccessToken(token) {
+    this.http.setAccessToken(token);
+  }
+  /** Clear the access token */
+  clearAccessToken() {
+    this.http.clearAccessToken();
+  }
+};
+export {
+  AlertsResource,
+  ApiKeysResource,
+  AuthResource,
+  DashboardResource,
+  EndpointsResource,
+  IteradianClient,
+  IteradianError,
+  LogsResource,
+  OrganizationsResource,
+  PlansResource,
+  RpcResource,
+  SubscriptionsResource,
+  SupportResource,
+  UsageResource
+};