@zqagent/shared 0.0.0-stage → 0.1.0

package/dist/hub-api.cjs

@@ -0,0 +1,901 @@
+"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/hub-api.ts
+var hub_api_exports = {};
+__export(hub_api_exports, {
+  activityKey: () => activityKey,
+  compareByActivity: () => compareByActivity,
+  hubAdminAddSocialQr: () => hubAdminAddSocialQr,
+  hubAdminAudit: () => hubAdminAudit,
+  hubAdminBillingReport: () => hubAdminBillingReport,
+  hubAdminClearCommunity: () => hubAdminClearCommunity,
+  hubAdminCommunity: () => hubAdminCommunity,
+  hubAdminDeleteFleet: () => hubAdminDeleteFleet,
+  hubAdminDeleteNode: () => hubAdminDeleteNode,
+  hubAdminDeleteUser: () => hubAdminDeleteUser,
+  hubAdminDisableUser: () => hubAdminDisableUser,
+  hubAdminEnableUser: () => hubAdminEnableUser,
+  hubAdminLinkZqai: () => hubAdminLinkZqai,
+  hubAdminMarkOrder: () => hubAdminMarkOrder,
+  hubAdminNodeBilling: () => hubAdminNodeBilling,
+  hubAdminNotifyUser: () => hubAdminNotifyUser,
+  hubAdminOrders: () => hubAdminOrders,
+  hubAdminOverview: () => hubAdminOverview,
+  hubAdminRefund: () => hubAdminRefund,
+  hubAdminRegisterAttempts: () => hubAdminRegisterAttempts,
+  hubAdminRemoveSocialQr: () => hubAdminRemoveSocialQr,
+  hubAdminSetRole: () => hubAdminSetRole,
+  hubAdminSocialQrs: () => hubAdminSocialQrs,
+  hubAdminTopup: () => hubAdminTopup,
+  hubAdminUpdateCommunity: () => hubAdminUpdateCommunity,
+  hubAdminUpdateNodeBilling: () => hubAdminUpdateNodeBilling,
+  hubAdminUpdateSocialQr: () => hubAdminUpdateSocialQr,
+  hubAdminUpdateUser: () => hubAdminUpdateUser,
+  hubAdminUserDetail: () => hubAdminUserDetail,
+  hubAdminUsers: () => hubAdminUsers,
+  hubAdminWallet: () => hubAdminWallet,
+  hubApiService: () => hubApiService,
+  hubApiTopup: () => hubApiTopup,
+  hubBillingExportUrl: () => hubBillingExportUrl,
+  hubCaptcha: () => hubCaptcha,
+  hubChangePassword: () => hubChangePassword,
+  hubChannels: () => hubChannels,
+  hubClearSmtpSettings: () => hubClearSmtpSettings,
+  hubCreateEnrollment: () => hubCreateEnrollment,
+  hubCreateFleet: () => hubCreateFleet,
+  hubCreateNodeGrant: () => hubCreateNodeGrant,
+  hubDeleteFleet: () => hubDeleteFleet,
+  hubDeleteNode: () => hubDeleteNode,
+  hubEnrollByAccount: () => hubEnrollByAccount,
+  hubEnrollByCode: () => hubEnrollByCode,
+  hubEnrollByToken: () => hubEnrollByToken,
+  hubEnrollNode: () => hubEnrollNode,
+  hubFleetPairing: () => hubFleetPairing,
+  hubGetNode: () => hubGetNode,
+  hubGetNodeById: () => hubGetNodeById,
+  hubGetUsage: () => hubGetUsage,
+  hubLeaveSharedNode: () => hubLeaveSharedNode,
+  hubListFleets: () => hubListFleets,
+  hubListNodeGrants: () => hubListNodeGrants,
+  hubListNodes: () => hubListNodes,
+  hubListProjects: () => hubListProjects,
+  hubListTasks: () => hubListTasks,
+  hubLogin: () => hubLogin,
+  hubLoginAccount: () => hubLoginAccount,
+  hubMarkNotificationsRead: () => hubMarkNotificationsRead,
+  hubMe: () => hubMe,
+  hubMoveNode: () => hubMoveNode,
+  hubNodeActivity: () => hubNodeActivity,
+  hubNodeUsageReport: () => hubNodeUsageReport,
+  hubNotificationStream: () => hubNotificationStream,
+  hubNotifications: () => hubNotifications,
+  hubNotifyEvents: () => hubNotifyEvents,
+  hubNotifyPreview: () => hubNotifyPreview,
+  hubNotifySettings: () => hubNotifySettings,
+  hubOrders: () => hubOrders,
+  hubOutgoingGrants: () => hubOutgoingGrants,
+  hubPins: () => hubPins,
+  hubPlans: () => hubPlans,
+  hubRealtimeCredential: () => hubRealtimeCredential,
+  hubRegister: () => hubRegister,
+  hubRegisterAccount: () => hubRegisterAccount,
+  hubRequestApiService: () => hubRequestApiService,
+  hubResetPassword: () => hubResetPassword,
+  hubRevokeNodeGrant: () => hubRevokeNodeGrant,
+  hubRotateApiKey: () => hubRotateApiKey,
+  hubSaveNotifySettings: () => hubSaveNotifySettings,
+  hubSavePins: () => hubSavePins,
+  hubSaveSmtpSettings: () => hubSaveSmtpSettings,
+  hubSendCodeStatus: () => hubSendCodeStatus,
+  hubSendEmailCode: () => hubSendEmailCode,
+  hubSendSms: () => hubSendSms,
+  hubSharedNodes: () => hubSharedNodes,
+  hubSmsStatus: () => hubSmsStatus,
+  hubSmtpSettings: () => hubSmtpSettings,
+  hubStatement: () => hubStatement,
+  hubSubscription: () => hubSubscription,
+  hubSyncOrder: () => hubSyncOrder,
+  hubTerminalCredential: () => hubTerminalCredential,
+  hubTestNotify: () => hubTestNotify,
+  hubUpdateFleet: () => hubUpdateFleet,
+  hubUpdateNode: () => hubUpdateNode,
+  hubUpdateNodeLabelSelf: () => hubUpdateNodeLabelSelf,
+  hubUpdateProfile: () => hubUpdateProfile,
+  hubWallet: () => hubWallet,
+  hubWalletTopup: () => hubWalletTopup,
+  setHubBaseResolver: () => setHubBaseResolver
+});
+module.exports = __toCommonJS(hub_api_exports);
+function activityKey(o) {
+  return o.lastStartedAt ?? o.lastCompletedAt ?? "";
+}
+function compareByActivity(a, b, tieBreak) {
+  const ak = activityKey(a);
+  const bk = activityKey(b);
+  if (ak !== bk) return bk.localeCompare(ak);
+  return tieBreak ? tieBreak(a, b) : 0;
+}
+var baseUrlResolver = null;
+function setHubBaseResolver(fn) {
+  baseUrlResolver = fn;
+}
+function resolveBase(baseUrl) {
+  return baseUrlResolver ? baseUrlResolver(baseUrl) : baseUrl;
+}
+var HUB_REQUEST_TIMEOUT_MS = 3e4;
+async function req(baseUrl, token, path, init = {}) {
+  const headers = {
+    ...init.body ? { "Content-Type": "application/json" } : {},
+    ...init.headers ?? {}
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const url = `${resolveBase(baseUrl).replace(/\/$/, "")}${path}`;
+  const method = (init.method ?? "GET").toUpperCase();
+  const attempts = method === "GET" ? 3 : 1;
+  const newTimeoutSignal = () => typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(HUB_REQUEST_TIMEOUT_MS) : void 0;
+  let lastError;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      const res = await fetch(url, {
+        ...init,
+        headers,
+        // 每次重试都要新的 signal：超时后的 signal 已 aborted，复用会立刻失败
+        signal: init.signal ?? newTimeoutSignal()
+      });
+      const text = await res.text();
+      let payload = null;
+      try {
+        payload = text ? JSON.parse(text) : null;
+      } catch {
+        throw new Error(`Hub \u54CD\u5E94\u975E\u6CD5\uFF08HTTP ${res.status}\uFF09`);
+      }
+      if (!res.ok) {
+        const err = payload?.error;
+        const e = new Error(err?.message ?? `HTTP ${res.status}`);
+        e.code = err?.code;
+        e.status = res.status;
+        throw e;
+      }
+      return payload?.data;
+    } catch (e) {
+      lastError = e;
+      const status = e.status;
+      const retryable = status === void 0 || status >= 500;
+      if (i + 1 >= attempts || !retryable) throw e;
+      await new Promise((r) => setTimeout(r, 300 * 2 ** i + Math.random() * 200));
+    }
+  }
+  throw lastError;
+}
+async function hubRegister(baseUrl, email, password) {
+  return hubRegisterAccount(baseUrl, { email, password });
+}
+async function hubRegisterAccount(baseUrl, input) {
+  return await req(baseUrl, null, "/api/hub/auth/register", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubLogin(baseUrl, email, password) {
+  return hubLoginAccount(baseUrl, { email, password });
+}
+async function hubLoginAccount(baseUrl, input) {
+  return await req(baseUrl, null, "/api/hub/auth/login", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubCaptcha(baseUrl) {
+  return await req(baseUrl, null, "/api/hub/auth/captcha");
+}
+async function hubSendSms(baseUrl, input) {
+  return await req(baseUrl, null, "/api/hub/auth/sms/send", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubSendCodeStatus(baseUrl, clientId) {
+  const qs = clientId ? `?clientId=${encodeURIComponent(clientId)}` : "";
+  return await req(baseUrl, null, `/api/hub/auth/code/status${qs}`);
+}
+async function hubSmsStatus(baseUrl, phone, clientId) {
+  const qs = new URLSearchParams({ phone });
+  if (clientId) qs.set("clientId", clientId);
+  return await req(
+    baseUrl,
+    null,
+    `/api/hub/auth/sms/status?${qs.toString()}`
+  );
+}
+async function hubSendEmailCode(baseUrl, input) {
+  return await req(baseUrl, null, "/api/hub/auth/email/send", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubResetPassword(baseUrl, input) {
+  return await req(baseUrl, null, "/api/hub/auth/password/reset", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubMe(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/me");
+}
+async function hubUpdateProfile(baseUrl, token, input) {
+  return await req(baseUrl, token, "/api/hub/me", {
+    method: "PATCH",
+    body: JSON.stringify(input)
+  });
+}
+async function hubTerminalCredential(baseUrl, token, fleetId, nodeId, client = "web") {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/fleets/${fleetId}/nodes/${encodeURIComponent(nodeId)}/terminal-credential`,
+    { method: "POST", body: JSON.stringify({ client }) }
+  );
+}
+async function hubRealtimeCredential(baseUrl, token, client = "web") {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/realtime-credential?client=${encodeURIComponent(client)}`
+  );
+}
+async function hubChangePassword(baseUrl, token, input) {
+  return await req(baseUrl, token, "/api/hub/auth/password", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubListFleets(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/fleets");
+}
+async function hubCreateFleet(baseUrl, token, name) {
+  return await req(baseUrl, token, "/api/hub/fleets", {
+    method: "POST",
+    body: JSON.stringify({ name })
+  });
+}
+async function hubDeleteFleet(baseUrl, token, fleetId) {
+  await req(baseUrl, token, `/api/hub/fleets/${fleetId}`, { method: "DELETE" });
+}
+async function hubUpdateFleet(baseUrl, token, fleetId, name) {
+  return await req(baseUrl, token, `/api/hub/fleets/${fleetId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ name })
+  });
+}
+async function hubFleetPairing(baseUrl, token, fleetId) {
+  return await req(baseUrl, token, `/api/hub/fleets/${fleetId}/pairing`);
+}
+async function hubCreateEnrollment(baseUrl, token, fleetId) {
+  return await req(baseUrl, token, `/api/hub/fleets/${fleetId}/enrollment`, {
+    method: "POST"
+  });
+}
+async function hubListNodes(baseUrl, token, fleetId) {
+  return await req(baseUrl, token, `/api/hub/fleets/${fleetId}/nodes`);
+}
+async function hubListProjects(baseUrl, token, opts = {}) {
+  const limit = Math.min(Math.max(Math.trunc(opts.limit ?? 20), 1), 200);
+  const offset = Math.max(Math.trunc(opts.offset ?? 0), 0);
+  const q = (opts.q ?? "").trim();
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/projects?limit=${limit}&offset=${offset}${q ? `&q=${encodeURIComponent(q)}` : ""}`
+  );
+}
+async function hubListTasks(baseUrl, token, opts = {}) {
+  const limit = Math.min(Math.max(Math.trunc(opts.limit ?? 50), 1), 500);
+  const offset = Math.max(Math.trunc(opts.offset ?? 0), 0);
+  const status = opts.status ?? "all";
+  const q = (opts.q ?? "").trim();
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/tasks?limit=${limit}&offset=${offset}&status=${encodeURIComponent(status)}` + (q ? `&q=${encodeURIComponent(q)}` : "")
+  );
+}
+async function hubGetNode(baseUrl, token, fleetId, nodeId) {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/fleets/${fleetId}/nodes/${encodeURIComponent(nodeId)}`
+  );
+}
+async function hubGetNodeById(baseUrl, token, nodeId) {
+  return await req(baseUrl, token, `/api/hub/nodes/${encodeURIComponent(nodeId)}`);
+}
+async function hubSharedNodes(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/shared/nodes");
+}
+async function hubOutgoingGrants(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/shared/outgoing");
+}
+async function hubListNodeGrants(baseUrl, token, fleetId, nodeId) {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/fleets/${fleetId}/nodes/${encodeURIComponent(nodeId)}/grants`
+  );
+}
+async function hubCreateNodeGrant(baseUrl, token, fleetId, nodeId, input) {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/fleets/${fleetId}/nodes/${encodeURIComponent(nodeId)}/grants`,
+    { method: "POST", body: JSON.stringify(input) }
+  );
+}
+async function hubRevokeNodeGrant(baseUrl, token, fleetId, nodeId, grantId) {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/fleets/${fleetId}/nodes/${encodeURIComponent(nodeId)}/grants/${grantId}`,
+    { method: "DELETE" }
+  );
+}
+async function hubLeaveSharedNode(baseUrl, token, nodeId) {
+  return await req(baseUrl, token, `/api/hub/shared/nodes/${encodeURIComponent(nodeId)}/leave`, {
+    method: "POST"
+  });
+}
+async function hubNodeActivity(baseUrl, token, nodeId, opts = {}) {
+  const limit = Math.min(Math.max(Math.trunc(opts.limit ?? 50), 1), 200);
+  const offset = Math.max(Math.trunc(opts.offset ?? 0), 0);
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/nodes/${encodeURIComponent(nodeId)}/activity?limit=${limit}&offset=${offset}`
+  );
+}
+async function hubEnrollNode(baseUrl, token, fleetId, nodeId, label) {
+  await req(baseUrl, token, `/api/hub/fleets/${fleetId}/nodes`, {
+    method: "POST",
+    body: JSON.stringify({ nodeId, label })
+  });
+}
+async function hubEnrollByCode(baseUrl, input) {
+  const data = await req(baseUrl, null, "/api/hub/enroll", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  return { hubUrl: baseUrl.replace(/\/$/, ""), ...data };
+}
+async function hubEnrollByAccount(baseUrl, input) {
+  const data = await req(baseUrl, null, "/api/hub/enroll/account", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  return { hubUrl: baseUrl.replace(/\/$/, ""), ...data };
+}
+async function hubEnrollByToken(baseUrl, token, input) {
+  const data = await req(baseUrl, token, "/api/hub/enroll/token", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  return { hubUrl: baseUrl.replace(/\/$/, ""), ...data };
+}
+async function hubDeleteNode(baseUrl, token, fleetId, nodeId) {
+  await req(baseUrl, token, `/api/hub/fleets/${fleetId}/nodes/${nodeId}`, { method: "DELETE" });
+}
+async function hubUpdateNode(baseUrl, token, fleetId, nodeId, label) {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/fleets/${fleetId}/nodes/${encodeURIComponent(nodeId)}`,
+    { method: "PATCH", body: JSON.stringify({ label }) }
+  );
+}
+async function hubUpdateNodeLabelSelf(baseUrl, fleetToken, input) {
+  return await req(baseUrl, fleetToken, "/api/hub/nodes/self/label", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubMoveNode(baseUrl, token, fleetId, nodeId, targetFleetId) {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/fleets/${fleetId}/nodes/${encodeURIComponent(nodeId)}`,
+    { method: "PATCH", body: JSON.stringify({ fleetId: targetFleetId }) }
+  );
+}
+async function hubPlans(baseUrl) {
+  return await req(baseUrl, null, "/api/hub/plans");
+}
+async function hubSubscription(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/subscription");
+}
+async function hubChannels(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/billing/channels");
+}
+async function hubOrders(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/orders");
+}
+async function hubSyncOrder(baseUrl, token, orderId) {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/orders/${encodeURIComponent(orderId)}/sync`
+  );
+}
+async function hubNotifications(baseUrl, token, limit = 50) {
+  return await req(baseUrl, token, `/api/hub/notifications?limit=${limit}`);
+}
+async function hubMarkNotificationsRead(baseUrl, token, input) {
+  return await req(baseUrl, token, "/api/hub/notifications/read", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubGetUsage(baseUrl, token, params = {}) {
+  const q = new URLSearchParams();
+  if (params.from) q.set("from", params.from);
+  if (params.to) q.set("to", params.to);
+  if (params.groupBy) q.set("groupBy", params.groupBy);
+  const qs = q.toString();
+  return await req(baseUrl, token, `/api/hub/usage${qs ? `?${qs}` : ""}`);
+}
+async function hubNodeUsageReport(baseUrl, token, nodeId, payload) {
+  await req(baseUrl, token, `/api/hub/nodes/${nodeId}/usage`, {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+}
+function adminQuery(params) {
+  const q = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0 || v === "") continue;
+    q.set(k, String(v));
+  }
+  const qs = q.toString();
+  return qs ? `?${qs}` : "";
+}
+async function hubAdminOverview(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/admin/overview");
+}
+async function hubAdminUsers(baseUrl, token, params = {}) {
+  const qs = adminQuery({
+    q: params.q,
+    status: params.status,
+    role: params.role,
+    plan: params.plan,
+    withUsage: params.withUsage ? 1 : void 0,
+    limit: params.limit,
+    offset: params.offset
+  });
+  return await req(baseUrl, token, `/api/hub/admin/users${qs}`);
+}
+async function hubAdminUserDetail(baseUrl, token, userId) {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/admin/users/${encodeURIComponent(userId)}`
+  );
+}
+async function hubAdminUpdateUser(baseUrl, token, userId, patch) {
+  return await req(baseUrl, token, `/api/hub/admin/users/${encodeURIComponent(userId)}`, {
+    method: "PATCH",
+    body: JSON.stringify(patch)
+  });
+}
+async function hubAdminDisableUser(baseUrl, token, userId) {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/admin/users/${encodeURIComponent(userId)}/disable`,
+    { method: "POST" }
+  );
+}
+async function hubAdminEnableUser(baseUrl, token, userId) {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/admin/users/${encodeURIComponent(userId)}/enable`,
+    { method: "POST" }
+  );
+}
+async function hubAdminDeleteUser(baseUrl, token, userId) {
+  return await req(baseUrl, token, `/api/hub/admin/users/${encodeURIComponent(userId)}`, {
+    method: "DELETE"
+  });
+}
+async function hubAdminSetRole(baseUrl, token, userId, role) {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/admin/users/${encodeURIComponent(userId)}/role`,
+    { method: "PATCH", body: JSON.stringify({ role }) }
+  );
+}
+async function hubAdminNotifyUser(baseUrl, token, userId, input) {
+  return await req(
+    baseUrl,
+    token,
+    `/api/hub/admin/users/${encodeURIComponent(userId)}/notify`,
+    { method: "POST", body: JSON.stringify(input) }
+  );
+}
+async function hubAdminDeleteFleet(baseUrl, token, fleetId) {
+  return await req(baseUrl, token, `/api/hub/admin/fleets/${encodeURIComponent(fleetId)}`, {
+    method: "DELETE"
+  });
+}
+async function hubAdminDeleteNode(baseUrl, token, nodeId) {
+  return await req(baseUrl, token, `/api/hub/admin/nodes/${encodeURIComponent(nodeId)}`, {
+    method: "DELETE"
+  });
+}
+async function hubAdminOrders(baseUrl, token, params = {}) {
+  const qs = adminQuery({
+    status: params.status,
+    provider: params.provider,
+    q: params.q,
+    from: params.from,
+    to: params.to,
+    limit: params.limit,
+    offset: params.offset
+  });
+  return await req(baseUrl, token, `/api/hub/admin/orders${qs}`);
+}
+async function hubAdminMarkOrder(baseUrl, token, orderId, input) {
+  return await req(baseUrl, token, `/api/hub/admin/orders/${encodeURIComponent(orderId)}/mark`, {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubAdminAudit(baseUrl, token, params = {}) {
+  const qs = adminQuery({
+    userId: params.userId,
+    action: params.action,
+    limit: params.limit,
+    offset: params.offset
+  });
+  return await req(baseUrl, token, `/api/hub/admin/audit${qs}`);
+}
+async function hubAdminRegisterAttempts(baseUrl, token, params = {}) {
+  const qs = adminQuery({
+    q: params.q,
+    success: params.success === void 0 ? void 0 : params.success ? 1 : 0,
+    limit: params.limit,
+    offset: params.offset
+  });
+  return await req(baseUrl, token, `/api/hub/admin/register-attempts${qs}`);
+}
+function hubNotificationStream(baseUrl, token, onNotification, onClosed, onActivity) {
+  const controller = new AbortController();
+  let cancelled = false;
+  const url = `${resolveBase(baseUrl).replace(/\/$/, "")}/api/hub/notifications/stream`;
+  (async () => {
+    try {
+      const res = await fetch(url, {
+        signal: controller.signal,
+        headers: { Accept: "text/event-stream", Authorization: `Bearer ${token}` }
+      });
+      if (!res.ok || !res.body) {
+        onClosed?.();
+        return;
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buf = "";
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        onActivity?.();
+        buf += decoder.decode(value, { stream: true });
+        let idx;
+        while ((idx = buf.indexOf("\n\n")) >= 0) {
+          const frame = buf.slice(0, idx);
+          buf = buf.slice(idx + 2);
+          const data = frame.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).join("\n");
+          if (!data) continue;
+          try {
+            onNotification(JSON.parse(data));
+          } catch {
+          }
+        }
+      }
+    } catch {
+    } finally {
+      if (!cancelled) onClosed?.();
+    }
+  })();
+  return () => {
+    cancelled = true;
+    controller.abort();
+  };
+}
+async function hubNotifySettings(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/notify/settings");
+}
+async function hubSaveNotifySettings(baseUrl, token, settings) {
+  return await req(baseUrl, token, "/api/hub/notify/settings", {
+    method: "PUT",
+    body: JSON.stringify(settings)
+  });
+}
+async function hubPins(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/pins");
+}
+async function hubSavePins(baseUrl, token, pins) {
+  return await req(baseUrl, token, "/api/hub/pins", {
+    method: "PUT",
+    body: JSON.stringify(pins)
+  });
+}
+async function hubTestNotify(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/notify/test", {
+    method: "POST"
+  });
+}
+async function hubNotifyEvents(baseUrl, token, limit = 50) {
+  const qs = `?limit=${encodeURIComponent(String(limit))}`;
+  return await req(baseUrl, token, `/api/hub/notify/events${qs}`);
+}
+async function hubSmtpSettings(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/notify/smtp");
+}
+async function hubSaveSmtpSettings(baseUrl, token, input) {
+  return await req(baseUrl, token, "/api/hub/notify/smtp", {
+    method: "PUT",
+    body: JSON.stringify(input)
+  });
+}
+async function hubClearSmtpSettings(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/notify/smtp", {
+    method: "DELETE"
+  });
+}
+async function hubNotifyPreview(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/notify/preview");
+}
+async function hubApiService(baseUrl, token, opts = {}) {
+  const q = new URLSearchParams();
+  if (opts.from) q.set("from", opts.from);
+  if (opts.to) q.set("to", opts.to);
+  if (opts.groupBy) q.set("groupBy", opts.groupBy);
+  const suffix = q.toString() ? `?${q}` : "";
+  return await req(baseUrl, token, `/api/hub/api-service${suffix}`);
+}
+async function hubRotateApiKey(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/api-service/key/rotate", {
+    method: "POST"
+  });
+}
+async function hubRequestApiService(baseUrl, token, input) {
+  return await req(baseUrl, token, "/api/hub/api-service/request", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubAdminNodeBilling(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/admin/node-billing");
+}
+async function hubAdminUpdateNodeBilling(baseUrl, token, pricing) {
+  return await req(baseUrl, token, "/api/hub/admin/node-billing", {
+    method: "PUT",
+    body: JSON.stringify(pricing)
+  });
+}
+async function hubAdminWallet(baseUrl, token, userId, opts = {}) {
+  const q = new URLSearchParams({ userId });
+  if (opts.from) q.set("from", opts.from);
+  if (opts.to) q.set("to", opts.to);
+  if (opts.groupBy) q.set("groupBy", opts.groupBy);
+  return await req(baseUrl, token, `/api/hub/admin/wallets?${q}`);
+}
+async function hubAdminTopup(baseUrl, token, userId, input) {
+  return await req(baseUrl, token, `/api/hub/admin/users/${userId}/wallet`, {
+    method: "POST",
+    body: JSON.stringify({ deltaYuan: input.amountYuan, note: input.note ?? "" })
+  });
+}
+async function hubAdminCommunity(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/admin/community");
+}
+async function hubAdminUpdateCommunity(baseUrl, token, dataUrl) {
+  return await req(baseUrl, token, "/api/hub/admin/community", {
+    method: "PUT",
+    body: JSON.stringify({ dataUrl })
+  });
+}
+async function hubAdminClearCommunity(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/admin/community", {
+    method: "DELETE"
+  });
+}
+async function hubAdminSocialQrs(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/admin/community/qrs");
+}
+async function hubAdminAddSocialQr(baseUrl, token, input) {
+  return await req(baseUrl, token, "/api/hub/admin/community/qrs", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubAdminUpdateSocialQr(baseUrl, token, id, patch) {
+  return await req(baseUrl, token, `/api/hub/admin/community/qrs/${encodeURIComponent(id)}`, {
+    method: "PUT",
+    body: JSON.stringify(patch)
+  });
+}
+async function hubAdminRemoveSocialQr(baseUrl, token, id) {
+  return await req(baseUrl, token, `/api/hub/admin/community/qrs/${encodeURIComponent(id)}`, {
+    method: "DELETE"
+  });
+}
+async function hubAdminLinkZqai(baseUrl, token, userId, input) {
+  return await req(baseUrl, token, `/api/hub/admin/users/${encodeURIComponent(userId)}/zqai`, {
+    method: "PUT",
+    body: JSON.stringify(input)
+  });
+}
+async function hubWallet(baseUrl, token) {
+  return await req(baseUrl, token, "/api/hub/wallet");
+}
+async function hubWalletTopup(baseUrl, token, input) {
+  return await req(baseUrl, token, "/api/hub/wallet/topup", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubApiTopup(baseUrl, token, input) {
+  return await req(baseUrl, token, "/api/hub/api-service/topup", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubAdminBillingReport(baseUrl, token, range = {}) {
+  const q = new URLSearchParams();
+  if (range.from) q.set("from", range.from);
+  if (range.to) q.set("to", range.to);
+  const suffix = q.toString() ? `?${q}` : "";
+  return await req(baseUrl, token, `/api/hub/admin/reports/billing${suffix}`);
+}
+function hubBillingExportUrl(baseUrl, range = {}) {
+  const q = new URLSearchParams();
+  if (range.from) q.set("from", range.from);
+  if (range.to) q.set("to", range.to);
+  const suffix = q.toString() ? `?${q}` : "";
+  return `${resolveBase(baseUrl).replace(/\/$/, "")}/api/hub/admin/reports/billing/export${suffix}`;
+}
+async function hubAdminRefund(baseUrl, token, userId, input) {
+  return await req(baseUrl, token, `/api/hub/admin/users/${encodeURIComponent(userId)}/refund`, {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function hubStatement(baseUrl, token, range = {}) {
+  const q = new URLSearchParams();
+  if (range.from) q.set("from", range.from);
+  if (range.to) q.set("to", range.to);
+  const suffix = q.toString() ? `?${q}` : "";
+  return await req(baseUrl, token, `/api/hub/statement${suffix}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activityKey,
+  compareByActivity,
+  hubAdminAddSocialQr,
+  hubAdminAudit,
+  hubAdminBillingReport,
+  hubAdminClearCommunity,
+  hubAdminCommunity,
+  hubAdminDeleteFleet,
+  hubAdminDeleteNode,
+  hubAdminDeleteUser,
+  hubAdminDisableUser,
+  hubAdminEnableUser,
+  hubAdminLinkZqai,
+  hubAdminMarkOrder,
+  hubAdminNodeBilling,
+  hubAdminNotifyUser,
+  hubAdminOrders,
+  hubAdminOverview,
+  hubAdminRefund,
+  hubAdminRegisterAttempts,
+  hubAdminRemoveSocialQr,
+  hubAdminSetRole,
+  hubAdminSocialQrs,
+  hubAdminTopup,
+  hubAdminUpdateCommunity,
+  hubAdminUpdateNodeBilling,
+  hubAdminUpdateSocialQr,
+  hubAdminUpdateUser,
+  hubAdminUserDetail,
+  hubAdminUsers,
+  hubAdminWallet,
+  hubApiService,
+  hubApiTopup,
+  hubBillingExportUrl,
+  hubCaptcha,
+  hubChangePassword,
+  hubChannels,
+  hubClearSmtpSettings,
+  hubCreateEnrollment,
+  hubCreateFleet,
+  hubCreateNodeGrant,
+  hubDeleteFleet,
+  hubDeleteNode,
+  hubEnrollByAccount,
+  hubEnrollByCode,
+  hubEnrollByToken,
+  hubEnrollNode,
+  hubFleetPairing,
+  hubGetNode,
+  hubGetNodeById,
+  hubGetUsage,
+  hubLeaveSharedNode,
+  hubListFleets,
+  hubListNodeGrants,
+  hubListNodes,
+  hubListProjects,
+  hubListTasks,
+  hubLogin,
+  hubLoginAccount,
+  hubMarkNotificationsRead,
+  hubMe,
+  hubMoveNode,
+  hubNodeActivity,
+  hubNodeUsageReport,
+  hubNotificationStream,
+  hubNotifications,
+  hubNotifyEvents,
+  hubNotifyPreview,
+  hubNotifySettings,
+  hubOrders,
+  hubOutgoingGrants,
+  hubPins,
+  hubPlans,
+  hubRealtimeCredential,
+  hubRegister,
+  hubRegisterAccount,
+  hubRequestApiService,
+  hubResetPassword,
+  hubRevokeNodeGrant,
+  hubRotateApiKey,
+  hubSaveNotifySettings,
+  hubSavePins,
+  hubSaveSmtpSettings,
+  hubSendCodeStatus,
+  hubSendEmailCode,
+  hubSendSms,
+  hubSharedNodes,
+  hubSmsStatus,
+  hubSmtpSettings,
+  hubStatement,
+  hubSubscription,
+  hubSyncOrder,
+  hubTerminalCredential,
+  hubTestNotify,
+  hubUpdateFleet,
+  hubUpdateNode,
+  hubUpdateNodeLabelSelf,
+  hubUpdateProfile,
+  hubWallet,
+  hubWalletTopup,
+  setHubBaseResolver
+});
+//# sourceMappingURL=hub-api.cjs.map