@zhoujinandrew/te-cli 1.0.0 → 1.0.2

package/dist/analysis-XB56ZN7H.js

@@ -0,0 +1,217 @@
+// src/commands/analysis/list-reports.ts
+var listReports = {
+  service: "analysis",
+  command: "+list-reports",
+  description: "List all analysis reports for a project",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("POST", "/v1/ta/event/listAll", {
+      projectId: ctx.num("project-id")
+    });
+  }
+};
+
+// src/commands/analysis/get-report.ts
+var getReport = {
+  service: "analysis",
+  command: "+get-report",
+  description: "Get full report definition by ID",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "report-id", type: "number", required: true, desc: "Report ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("GET", "/v1/ta/event/reportsearch", {
+      projectId: ctx.num("project-id"),
+      reportId: ctx.num("report-id")
+    });
+  }
+};
+
+// src/commands/analysis/save-report.ts
+var saveReport = {
+  service: "analysis",
+  command: "+save-report",
+  description: "Save (create/update) an analysis report",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "report-name", type: "string", required: true, desc: "Report name" },
+    { name: "report-model", type: "number", required: true, desc: "0=Event, 1=Retention, 2=Funnel, 10=Distribution" },
+    { name: "events", type: "json", required: true, desc: "Events configuration array" },
+    { name: "event-view", type: "json", required: true, desc: "Event view configuration" }
+  ],
+  risk: "write",
+  execute: async (ctx) => {
+    return ctx.api("POST", "/v1/ta/event/reportsave", {
+      projectId: ctx.num("project-id")
+    }, {
+      reportName: ctx.str("report-name"),
+      reportModel: ctx.num("report-model"),
+      events: ctx.json("events"),
+      eventView: ctx.json("event-view")
+    });
+  }
+};
+
+// src/commands/analysis/list-dashboards.ts
+var listDashboards = {
+  service: "analysis",
+  command: "+list-dashboards",
+  description: "List all dashboards for a project",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("GET", "/v1/ta/dashboard/all-dashboards", {
+      projectId: ctx.num("project-id")
+    });
+  }
+};
+
+// src/commands/analysis/get-dashboard.ts
+var getDashboard = {
+  service: "analysis",
+  command: "+get-dashboard",
+  description: "Get dashboard details by ID",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.api("POST", "/v1/ta/dashboard/search-dashboard", {
+      projectId: ctx.num("project-id"),
+      dashbordId: ctx.num("dashboard-id")
+    });
+  }
+};
+
+// src/commands/analysis/create-dashboard.ts
+var createDashboard = {
+  service: "analysis",
+  command: "+create-dashboard",
+  description: "Create a new dashboard",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "dashboard-name", type: "string", required: true, desc: "Dashboard name" }
+  ],
+  risk: "write",
+  execute: async (ctx) => {
+    return ctx.api("POST", "/v1/ta/dashboard/create-dashboard", {
+      projectId: ctx.num("project-id")
+    }, {
+      dashboardName: ctx.str("dashboard-name")
+    });
+  }
+};
+
+// src/commands/analysis/update-dashboard.ts
+var updateDashboard = {
+  service: "analysis",
+  command: "+update-dashboard",
+  description: "Update dashboard report layout",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID" },
+    { name: "reports", type: "json", required: true, desc: "[{reportId, reportWidth?, indexOrder}]" }
+  ],
+  risk: "write",
+  execute: async (ctx) => {
+    return ctx.api("POST", "/v1/ta/dashboard/update-dashboard", {
+      projectId: ctx.num("project-id")
+    }, {
+      dashbordId: ctx.num("dashboard-id"),
+      reports: ctx.json("reports")
+    });
+  }
+};
+
+// src/commands/analysis/list-dashboard-reports.ts
+var listDashboardReports = {
+  service: "analysis",
+  command: "+list-dashboard-reports",
+  description: "List reports within a dashboard",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    const result = await ctx.api("POST", "/v1/ta/dashboard/search-dashboard", {
+      projectId: ctx.num("project-id")
+    }, {
+      dashboardId: ctx.num("dashboard-id")
+    });
+    return result?.eventReportList ?? result;
+  }
+};
+
+// src/commands/analysis/query-report-data.ts
+var queryReportData = {
+  service: "analysis",
+  command: "+query-report-data",
+  description: "Query report data by report ID",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "report-id", type: "number", required: true, desc: "Report ID" },
+    { name: "dashboard-id", type: "number", desc: "Dashboard ID (optional)" },
+    { name: "start-time", type: "string", desc: "Start time (YYYY-MM-DD HH:mm:ss)" },
+    { name: "end-time", type: "string", desc: "End time (YYYY-MM-DD HH:mm:ss)" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    const projectId = ctx.num("project-id");
+    const reportId = ctx.num("report-id");
+    const report = await ctx.api("GET", "/v1/ta/event/reportsearch", {
+      projectId,
+      reportId
+    });
+    const qp = {
+      events: report.events,
+      eventView: report.eventView
+    };
+    const startTime = ctx.str("start-time");
+    const endTime = ctx.str("end-time");
+    if (startTime) qp.eventView = { ...qp.eventView, startTime };
+    if (endTime) qp.eventView = { ...qp.eventView, endTime };
+    return ctx.queryReportData(projectId, reportId, qp, report.reportModel || 0);
+  }
+};
+
+// src/commands/analysis/query-sql.ts
+var querySql = {
+  service: "analysis",
+  command: "+query-sql",
+  description: "Execute a SQL query against the project",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "sql", type: "string", required: true, desc: "SQL query string" }
+  ],
+  risk: "read",
+  execute: async (ctx) => {
+    return ctx.querySql(ctx.num("project-id"), ctx.str("sql"));
+  }
+};
+
+// src/commands/analysis/index.ts
+var commands = [
+  listReports,
+  getReport,
+  saveReport,
+  listDashboards,
+  getDashboard,
+  createDashboard,
+  updateDashboard,
+  listDashboardReports,
+  queryReportData,
+  querySql
+];
+var analysis_default = commands;
+export {
+  analysis_default as default
+};

package/dist/chunk-4OJI46I5.js

@@ -0,0 +1,148 @@
+import {
+  clearToken,
+  getToken,
+  resolveHost
+} from "./chunk-P7NQZGSZ.js";
+
+// src/core/client.ts
+import WebSocket from "ws";
+import { randomBytes } from "crypto";
+function genRequestId(prefix) {
+  const rand = randomBytes(4).toString("base64url").slice(0, 8);
+  return `${prefix}@@${rand}`;
+}
+function buildUrl(baseUrl, modulePath, params = {}) {
+  const base = baseUrl.replace(/\/$/, "");
+  const p = modulePath.startsWith("/") ? modulePath : `/${modulePath}`;
+  const url = new URL(`${base}${p}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+  }
+  return url.toString();
+}
+function buildWsUrl(baseUrl, token) {
+  const base = baseUrl.replace(/\/$/, "");
+  const wsBase = base.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+  return `${wsBase}/v1/ta-websocket/query/${token}`;
+}
+async function request(method, modulePath, params = {}, body = null, retry = true, hostUrl) {
+  const resolvedHost = resolveHost(hostUrl);
+  const token = await getToken(resolvedHost);
+  const url = buildUrl(resolvedHost, modulePath, params);
+  const headers = {
+    "Authorization": `bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  const options = { method, headers };
+  if (body && method !== "GET") options.body = JSON.stringify(body);
+  if (process.env.TE_DEBUG) {
+    console.error(`[DEBUG] ${method} ${url}`);
+    console.error(`[DEBUG] body: ${options.body ?? "(none)"}`);
+  }
+  const resp = await fetch(url, options);
+  if ((resp.status === 401 || resp.status === 403) && retry) {
+    clearToken(resolvedHost);
+    return request(method, modulePath, params, body, false, resolvedHost);
+  }
+  const data = await resp.json();
+  if (data.return_code === -1001 && retry) {
+    clearToken(resolvedHost);
+    return request(method, modulePath, params, body, false, resolvedHost);
+  }
+  if (data.return_code !== 0 && data.return_code !== void 0) {
+    throw new Error(`TE API error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
+  }
+  return data.data !== void 0 ? data.data : data;
+}
+async function httpGet(modulePath, params = {}, hostUrl) {
+  return request("GET", modulePath, params, null, true, hostUrl);
+}
+async function httpPost(modulePath, params = {}, body, hostUrl) {
+  return request("POST", modulePath, params, body ?? {}, true, hostUrl);
+}
+async function wsQueryOnce(projectId, requestId, qp, eventModel, options = {}, token, hostUrl, timeoutMs = 3e4) {
+  const wsUrl = buildWsUrl(hostUrl, token);
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl);
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new Error(`WebSocket query timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    ws.on("open", () => {
+      const payload = {
+        requestId,
+        projectId,
+        eventModel,
+        qp: typeof qp === "string" ? qp : JSON.stringify(qp),
+        searchSource: options.searchSource || "reportQuery",
+        querySource: options.querySource || "single_report",
+        contentTranslate: options.contentTranslate !== false,
+        ...options.extra || {}
+      };
+      ws.send(JSON.stringify(["data", payload, { channel: "ta" }]));
+    });
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (Array.isArray(msg) && msg.length >= 2) {
+          const data = msg[1];
+          if (data.requestId === requestId && data.progress === 100) {
+            clearTimeout(timer);
+            ws.close();
+            resolve(data);
+          }
+        }
+      } catch {
+      }
+    });
+    ws.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    ws.on("close", () => {
+      clearTimeout(timer);
+    });
+  });
+}
+async function wsQuery(projectId, requestId, qp, eventModel, options = {}, hostUrl) {
+  const resolvedHost = resolveHost(hostUrl);
+  const token = await getToken(resolvedHost);
+  try {
+    return await wsQueryOnce(projectId, requestId, qp, eventModel, options, token, resolvedHost);
+  } catch (err) {
+    const msg = err.message || "";
+    if (msg.includes("401") || msg.includes("403") || msg.includes("auth")) {
+      clearToken(resolvedHost);
+      const newToken = await getToken(resolvedHost);
+      return wsQueryOnce(projectId, requestId, qp, eventModel, options, newToken, resolvedHost);
+    }
+    throw err;
+  }
+}
+async function querySql(projectId, sql, hostUrl) {
+  const requestId = genRequestId("sqlIde");
+  const qp = {
+    events: { sql },
+    eventView: { sqlViewParams: [] }
+  };
+  return wsQuery(projectId, requestId, qp, 10, {
+    searchSource: "sqlIde",
+    querySource: "sqlIde"
+  }, hostUrl);
+}
+async function queryReportData(projectId, reportId, qp, eventModel, options = {}, hostUrl) {
+  const requestId = genRequestId("reportQuery");
+  return wsQuery(projectId, requestId, qp, eventModel, {
+    searchSource: "reportQuery",
+    querySource: "single_report",
+    ...options
+  }, hostUrl);
+}
+
+export {
+  httpGet,
+  httpPost,
+  wsQuery,
+  querySql,
+  queryReportData
+};

package/dist/chunk-GZG7YDWV.js

@@ -0,0 +1,145 @@
+import {
+  clearToken,
+  getToken,
+  resolveHost
+} from "./chunk-P7NQZGSZ.js";
+
+// src/core/client.ts
+import WebSocket from "ws";
+import { randomBytes } from "crypto";
+function genRequestId(prefix) {
+  const rand = randomBytes(4).toString("base64url").slice(0, 8);
+  return `${prefix}@@${rand}`;
+}
+function buildUrl(baseUrl, modulePath, params = {}) {
+  const base = baseUrl.replace(/\/$/, "");
+  const p = modulePath.startsWith("/") ? modulePath : `/${modulePath}`;
+  const url = new URL(`${base}${p}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+  }
+  return url.toString();
+}
+function buildWsUrl(baseUrl, token) {
+  const base = baseUrl.replace(/\/$/, "");
+  const wsBase = base.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+  return `${wsBase}/v1/ta-websocket/query/${token}`;
+}
+async function request(method, modulePath, params = {}, body = null, retry = true, hostUrl) {
+  const resolvedHost = resolveHost(hostUrl);
+  const token = await getToken(resolvedHost);
+  const url = buildUrl(resolvedHost, modulePath, params);
+  const headers = {
+    "Authorization": `bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  const options = { method, headers };
+  if (body && method !== "GET") options.body = JSON.stringify(body);
+  const resp = await fetch(url, options);
+  if ((resp.status === 401 || resp.status === 403) && retry) {
+    clearToken(resolvedHost);
+    return request(method, modulePath, params, body, false, resolvedHost);
+  }
+  const data = await resp.json();
+  if (data.return_code === -1001 && retry) {
+    clearToken(resolvedHost);
+    return request(method, modulePath, params, body, false, resolvedHost);
+  }
+  if (data.return_code !== 0 && data.return_code !== void 0) {
+    throw new Error(`TE API error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
+  }
+  return data.data !== void 0 ? data.data : data;
+}
+async function httpGet(modulePath, params = {}, hostUrl) {
+  return request("GET", modulePath, params, null, true, hostUrl);
+}
+async function httpPost(modulePath, params = {}, body, hostUrl) {
+  return request("POST", modulePath, params, body ?? {}, true, hostUrl);
+}
+async function wsQueryOnce(projectId, requestId, qp, eventModel, options = {}, token, hostUrl, timeoutMs = 3e4) {
+  const wsUrl = buildWsUrl(hostUrl, token);
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl);
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new Error(`WebSocket query timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    ws.on("open", () => {
+      const payload = {
+        requestId,
+        projectId,
+        eventModel,
+        qp: typeof qp === "string" ? qp : JSON.stringify(qp),
+        searchSource: options.searchSource || "reportQuery",
+        querySource: options.querySource || "single_report",
+        contentTranslate: options.contentTranslate !== false,
+        ...options.extra || {}
+      };
+      ws.send(JSON.stringify(["data", payload, { channel: "ta" }]));
+    });
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (Array.isArray(msg) && msg.length >= 2) {
+          const data = msg[1];
+          if (data.requestId === requestId && data.progress === 100) {
+            clearTimeout(timer);
+            ws.close();
+            resolve(data);
+          }
+        }
+      } catch {
+      }
+    });
+    ws.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    ws.on("close", () => {
+      clearTimeout(timer);
+    });
+  });
+}
+async function wsQuery(projectId, requestId, qp, eventModel, options = {}, hostUrl) {
+  const resolvedHost = resolveHost(hostUrl);
+  const token = await getToken(resolvedHost);
+  try {
+    return await wsQueryOnce(projectId, requestId, qp, eventModel, options, token, resolvedHost);
+  } catch (err) {
+    const msg = err.message || "";
+    if (msg.includes("401") || msg.includes("403") || msg.includes("auth")) {
+      clearToken(resolvedHost);
+      const newToken = await getToken(resolvedHost);
+      return wsQueryOnce(projectId, requestId, qp, eventModel, options, newToken, resolvedHost);
+    }
+    throw err;
+  }
+}
+async function querySql(projectId, sql, hostUrl) {
+  const requestId = genRequestId("sqlIde");
+  const qp = {
+    events: { sql },
+    eventView: { sqlViewParams: [] }
+  };
+  return wsQuery(projectId, requestId, qp, 10, {
+    searchSource: "sqlIde",
+    querySource: "sqlIde"
+  }, hostUrl);
+}
+async function queryReportData(projectId, reportId, qp, eventModel, options = {}, hostUrl) {
+  const dashboardId = options.dashboardId || 0;
+  const requestId = genRequestId(`${projectId}_${dashboardId}_${reportId}`);
+  return wsQuery(projectId, requestId, qp, eventModel, {
+    searchSource: options.searchSource || "model_search",
+    querySource: options.querySource || "module",
+    ...options
+  }, hostUrl);
+}
+
+export {
+  httpGet,
+  httpPost,
+  wsQuery,
+  querySql,
+  queryReportData
+};

package/dist/chunk-O6AQSK3A.js

@@ -0,0 +1,149 @@
+import {
+  clearToken,
+  getToken,
+  resolveHost
+} from "./chunk-P7NQZGSZ.js";
+
+// src/core/client.ts
+import WebSocket from "ws";
+import { randomBytes } from "crypto";
+function genRequestId(prefix) {
+  const rand = randomBytes(4).toString("base64url").slice(0, 8);
+  return `${prefix}@@${rand}`;
+}
+function buildUrl(baseUrl, modulePath, params = {}) {
+  const base = baseUrl.replace(/\/$/, "");
+  const p = modulePath.startsWith("/") ? modulePath : `/${modulePath}`;
+  const url = new URL(`${base}${p}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+  }
+  return url.toString();
+}
+function buildWsUrl(baseUrl, token) {
+  const base = baseUrl.replace(/\/$/, "");
+  const wsBase = base.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+  return `${wsBase}/v1/ta-websocket/query/${token}`;
+}
+async function request(method, modulePath, params = {}, body = null, retry = true, hostUrl) {
+  const resolvedHost = resolveHost(hostUrl);
+  const token = await getToken(resolvedHost);
+  const url = buildUrl(resolvedHost, modulePath, params);
+  const headers = {
+    "Authorization": `bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  const options = { method, headers };
+  if (body && method !== "GET") options.body = JSON.stringify(body);
+  if (process.env.TE_DEBUG) {
+    console.error(`[DEBUG] ${method} ${url}`);
+    console.error(`[DEBUG] body: ${options.body ?? "(none)"}`);
+  }
+  const resp = await fetch(url, options);
+  if ((resp.status === 401 || resp.status === 403) && retry) {
+    clearToken(resolvedHost);
+    return request(method, modulePath, params, body, false, resolvedHost);
+  }
+  const data = await resp.json();
+  if (data.return_code === -1001 && retry) {
+    clearToken(resolvedHost);
+    return request(method, modulePath, params, body, false, resolvedHost);
+  }
+  if (data.return_code !== 0 && data.return_code !== void 0) {
+    throw new Error(`TE API error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
+  }
+  return data.data !== void 0 ? data.data : data;
+}
+async function httpGet(modulePath, params = {}, hostUrl) {
+  return request("GET", modulePath, params, null, true, hostUrl);
+}
+async function httpPost(modulePath, params = {}, body, hostUrl) {
+  return request("POST", modulePath, params, body ?? {}, true, hostUrl);
+}
+async function wsQueryOnce(projectId, requestId, qp, eventModel, options = {}, token, hostUrl, timeoutMs = 3e4) {
+  const wsUrl = buildWsUrl(hostUrl, token);
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl);
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new Error(`WebSocket query timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    ws.on("open", () => {
+      const payload = {
+        requestId,
+        projectId,
+        eventModel,
+        qp: typeof qp === "string" ? qp : JSON.stringify(qp),
+        searchSource: options.searchSource || "reportQuery",
+        querySource: options.querySource || "single_report",
+        contentTranslate: options.contentTranslate !== false,
+        ...options.extra || {}
+      };
+      ws.send(JSON.stringify(["data", payload, { channel: "ta" }]));
+    });
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (Array.isArray(msg) && msg.length >= 2) {
+          const data = msg[1];
+          if (data.requestId === requestId && data.progress === 100) {
+            clearTimeout(timer);
+            ws.close();
+            resolve(data);
+          }
+        }
+      } catch {
+      }
+    });
+    ws.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    ws.on("close", () => {
+      clearTimeout(timer);
+    });
+  });
+}
+async function wsQuery(projectId, requestId, qp, eventModel, options = {}, hostUrl) {
+  const resolvedHost = resolveHost(hostUrl);
+  const token = await getToken(resolvedHost);
+  try {
+    return await wsQueryOnce(projectId, requestId, qp, eventModel, options, token, resolvedHost);
+  } catch (err) {
+    const msg = err.message || "";
+    if (msg.includes("401") || msg.includes("403") || msg.includes("auth")) {
+      clearToken(resolvedHost);
+      const newToken = await getToken(resolvedHost);
+      return wsQueryOnce(projectId, requestId, qp, eventModel, options, newToken, resolvedHost);
+    }
+    throw err;
+  }
+}
+async function querySql(projectId, sql, hostUrl) {
+  const requestId = genRequestId("sqlIde");
+  const qp = {
+    events: { sql },
+    eventView: { sqlViewParams: [] }
+  };
+  return wsQuery(projectId, requestId, qp, 10, {
+    searchSource: "sqlIde",
+    querySource: "sqlIde"
+  }, hostUrl);
+}
+async function queryReportData(projectId, reportId, qp, eventModel, options = {}, hostUrl) {
+  const dashboardId = options.dashboardId || 0;
+  const requestId = genRequestId(`${projectId}_${dashboardId}_${reportId}`);
+  return wsQuery(projectId, requestId, qp, eventModel, {
+    searchSource: options.searchSource || "model_search",
+    querySource: options.querySource || "module",
+    ...options
+  }, hostUrl);
+}
+
+export {
+  httpGet,
+  httpPost,
+  wsQuery,
+  querySql,
+  queryReportData
+};

package/dist/client-6TVMBUGP.js

@@ -0,0 +1,16 @@
+import {
+  httpGet,
+  httpPost,
+  queryReportData,
+  querySql,
+  wsQuery
+} from "./chunk-GZG7YDWV.js";
+import "./chunk-P7NQZGSZ.js";
+import "./chunk-CFCHSAMQ.js";
+export {
+  httpGet,
+  httpPost,
+  queryReportData,
+  querySql,
+  wsQuery
+};

package/dist/client-BYCN6252.js

@@ -0,0 +1,16 @@
+import {
+  httpGet,
+  httpPost,
+  queryReportData,
+  querySql,
+  wsQuery
+} from "./chunk-4OJI46I5.js";
+import "./chunk-P7NQZGSZ.js";
+import "./chunk-CFCHSAMQ.js";
+export {
+  httpGet,
+  httpPost,
+  queryReportData,
+  querySql,
+  wsQuery
+};