test-api-client 0.0.1

package/dist/index.js

@@ -0,0 +1,1092 @@
+'use strict';
+
+var axios = require('axios');
+var CryptoJS = require('crypto-js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var CryptoJS__default = /*#__PURE__*/_interopDefault(CryptoJS);
+
+// src/types.ts
+var ErrorLevel = /* @__PURE__ */ ((ErrorLevel3) => {
+  ErrorLevel3[ErrorLevel3["SUCCESS"] = 0] = "SUCCESS";
+  ErrorLevel3[ErrorLevel3["SYSTEM"] = 1] = "SYSTEM";
+  ErrorLevel3[ErrorLevel3["CLIENT_PARAM"] = 2] = "CLIENT_PARAM";
+  ErrorLevel3[ErrorLevel3["AUTH"] = 3] = "AUTH";
+  ErrorLevel3[ErrorLevel3["BUSINESS"] = 4] = "BUSINESS";
+  ErrorLevel3[ErrorLevel3["RESOURCE"] = 5] = "RESOURCE";
+  ErrorLevel3[ErrorLevel3["NETWORK"] = 6] = "NETWORK";
+  ErrorLevel3[ErrorLevel3["FILE_MEDIA"] = 7] = "FILE_MEDIA";
+  ErrorLevel3[ErrorLevel3["DEVICE_HARDWARE"] = 8] = "DEVICE_HARDWARE";
+  ErrorLevel3[ErrorLevel3["THIRD_PARTY"] = 9] = "THIRD_PARTY";
+  return ErrorLevel3;
+})(ErrorLevel || {});
+var FunctionModule = /* @__PURE__ */ ((FunctionModule4) => {
+  FunctionModule4["GENERAL"] = "00";
+  FunctionModule4["USER_AUTH"] = "01";
+  FunctionModule4["SELF_CHECK"] = "02";
+  FunctionModule4["AIRLINE"] = "03";
+  FunctionModule4["FENCE"] = "04";
+  FunctionModule4["REAL_TIME_DATA"] = "05";
+  FunctionModule4["VIDEO_STREAM"] = "06";
+  FunctionModule4["AUDIO_STREAM"] = "07";
+  FunctionModule4["MEDIA_SERVICE"] = "08";
+  FunctionModule4["AV_CONTROL"] = "09";
+  FunctionModule4["LOG_FILE"] = "10";
+  FunctionModule4["REMOTE_CONTROL"] = "11";
+  FunctionModule4["FLIGHT_STATUS"] = "12";
+  return FunctionModule4;
+})(FunctionModule || {});
+var ApiError = class extends Error {
+  /**
+   * 创建ApiError实例
+   * @param params - 错误参数
+   * @param params.message - 错误消息
+   * @param params.type - 错误类型
+   * @param params.httpStatus - HTTP状态码（可选）
+   * @param params.code - 业务错误码（可选）
+   * @param params.subCode - 业务子错误码（可选）
+   * @param params.subMsg - 业务子错误消息（可选）
+   * @param params.errorLevel - 错误级别（可选）
+   * @param params.module - 功能模块（可选）
+   * @param params.raw - 原始错误数据（可选）
+   */
+  constructor(params) {
+    super(params.message);
+    this.name = "ApiError";
+    this.type = params.type;
+    this.httpStatus = params.httpStatus;
+    this.code = params.code;
+    this.subCode = params.subCode;
+    this.subMsg = params.subMsg;
+    this.errorLevel = params.errorLevel;
+    this.module = params.module;
+    this.raw = params.raw;
+  }
+};
+
+// src/client/logger.ts
+var LOG_LEVEL_WEIGHT = {
+  "ALL": 0,
+  "TRACE": 1,
+  "DEBUG": 2,
+  "INFO": 3,
+  "WARN": 4,
+  "ERROR": 5,
+  "FATAL": 6,
+  "OFF": 7
+};
+function shouldHandle(config, level) {
+  var _a;
+  if (!(config == null ? void 0 : config.debug)) return false;
+  const cfgLevel = (_a = config.logLevel) != null ? _a : "INFO";
+  if (cfgLevel === "OFF") return false;
+  if (cfgLevel === "ALL") return true;
+  return LOG_LEVEL_WEIGHT[level] >= LOG_LEVEL_WEIGHT[cfgLevel];
+}
+function formatSensitiveData(data) {
+  if (typeof data !== "object" || data === null) {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => formatSensitiveData(item));
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    const lowerKey = key.toLowerCase();
+    if (lowerKey.includes("password") || lowerKey.includes("passwd") || lowerKey.includes("token") || lowerKey.includes("auth") || lowerKey.includes("secret")) {
+      result[key] = typeof value === "string" ? "******" : "******";
+    } else {
+      result[key] = formatSensitiveData(value);
+    }
+  }
+  return result;
+}
+function generateStructuredLog(config, level, event, message, httpLog, meta) {
+  const structuredLog = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    module: "api-client",
+    event,
+    message
+  };
+  if (httpLog) {
+    if (httpLog.url && httpLog.method) {
+      structuredLog.request = {
+        url: httpLog.url,
+        method: httpLog.method,
+        headers: httpLog.headers,
+        body: formatSensitiveData(httpLog.request)
+      };
+    }
+    if (httpLog.response && typeof httpLog.response === "object") {
+      const responseObj = httpLog.response;
+      structuredLog.response = {
+        status: responseObj.status || responseObj.code || 0,
+        body: responseObj
+      };
+    }
+    if (httpLog.durationMs) {
+      structuredLog.duration_ms = httpLog.durationMs;
+    }
+  }
+  return structuredLog;
+}
+function formatJsonLog(log) {
+  return JSON.stringify(log, null, 2);
+}
+function formatTextLog(log) {
+  const { timestamp, level, module, event, message, duration_ms } = log;
+  let text = `${timestamp} [${level}] [${module}] [${event}]`;
+  if (log.trace_id) {
+    text += ` [trace_id: ${log.trace_id}]`;
+  }
+  if (duration_ms) {
+    text += ` [duration: ${duration_ms}ms]`;
+  }
+  text += ` - ${message}`;
+  if (log.request) {
+    text += `
+  Request: ${log.request.method} ${log.request.url}`;
+    if (log.request.headers) {
+      text += `
+  Headers: ${JSON.stringify(log.request.headers)}`;
+    }
+    if (log.request.body) {
+      text += `
+  Body: ${JSON.stringify(log.request.body)}`;
+    }
+  }
+  if (log.response) {
+    text += `
+  Response: ${log.response.status}`;
+    if (log.response.body) {
+      text += `
+  Body: ${JSON.stringify(log.response.body)}`;
+    }
+  }
+  return text;
+}
+function formatLog(config, log) {
+  var _a;
+  const formatType = (_a = config == null ? void 0 : config.logFormat) != null ? _a : 1;
+  return formatType === 1 ? formatJsonLog(log) : formatTextLog(log);
+}
+function printLog(config, log) {
+  var _a;
+  const logOutput = (_a = config == null ? void 0 : config.logOutput) != null ? _a : [1];
+  if (!logOutput.includes(1)) return;
+  const formattedLog = formatLog(config, log);
+  switch (log.level) {
+    case "DEBUG":
+    case "TRACE":
+      console.debug(formattedLog);
+      break;
+    case "INFO":
+      console.info(formattedLog);
+      break;
+    case "WARN":
+      console.warn(formattedLog);
+      break;
+    case "ERROR":
+    case "FATAL":
+      console.error(formattedLog);
+      break;
+    default:
+      console.log(formattedLog);
+  }
+}
+function sendLogToClient(config, log) {
+  var _a, _b;
+  const logOutput = (_a = config == null ? void 0 : config.logOutput) != null ? _a : [1];
+  if (!logOutput.includes(2)) return;
+  (_b = config == null ? void 0 : config.logger) == null ? void 0 : _b.call(config, log, log.level, log);
+}
+function handleHttpLog(config, level, httpLog) {
+  if (!shouldHandle(config, level)) return;
+  const message = `${httpLog.name || "HTTP Request"} ${httpLog.method || ""} ${httpLog.url || ""}`;
+  const structuredLog = generateStructuredLog(config, level, "request", message, httpLog);
+  printLog(config, structuredLog);
+  sendLogToClient(config, structuredLog);
+}
+function getUri(urlOrPath) {
+  try {
+    const url = new URL(urlOrPath, "https://example.com");
+    return url.pathname;
+  } catch {
+    return urlOrPath.split("?")[0];
+  }
+}
+function serializeValue(value) {
+  if (typeof value === "object" && value !== null) {
+    if (value instanceof Date) return value.toISOString();
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function generateSignature(params, secret, salt) {
+  const entries = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value != null && value !== "") {
+      entries.push([key, value]);
+    }
+  }
+  entries.sort(
+    (a, b) => a[0].toLowerCase().localeCompare(b[0].toLowerCase())
+  );
+  let strToSign = "";
+  for (const [key, value] of entries) {
+    strToSign += `${key.toLowerCase()}=${serializeValue(value)}&`;
+  }
+  strToSign += `secret=${secret}`;
+  const hmac = CryptoJS__default.default.HmacMD5(strToSign, salt);
+  return hmac.toString(CryptoJS__default.default.enc.Hex);
+}
+function randomNonce(length = 32) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+function generateSign(input) {
+  const params = {};
+  params.uri = getUri(input.uri);
+  params["X-Timestamp"] = String(input.timestamp);
+  params["X-Nonce"] = input.nonce;
+  if (input.query) {
+    Object.assign(params, input.query);
+  }
+  if (input.body !== void 0 && input.body !== null && input.body !== "") {
+    if (typeof input.body === "object" && !Array.isArray(input.body)) {
+      Object.assign(params, input.body);
+    } else if (typeof input.body === "string") {
+      const s = input.body.trim();
+      if (s.startsWith("{") && s.endsWith("}")) {
+        try {
+          const obj = JSON.parse(s);
+          if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+            Object.assign(params, obj);
+          } else {
+            params.body = input.body;
+          }
+        } catch {
+          params.body = input.body;
+        }
+      } else {
+        params.body = input.body;
+      }
+    } else {
+      params.body = input.body;
+    }
+  }
+  const sign = generateSignature(params, input.secret, input.salt);
+  const entries = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value != null && value !== "") {
+      entries.push([key, value]);
+    }
+  }
+  entries.sort((a, b) => a[0].toLowerCase().localeCompare(b[0].toLowerCase()));
+  let signString = "";
+  for (const [key, value] of entries) {
+    signString += `${key.toLowerCase()}=${serializeValue(value)}&`;
+  }
+  signString += `secret=${input.secret}`;
+  return { sign, signString };
+}
+
+// src/client/state.ts
+var state = {};
+
+// src/client/token.ts
+function setApiToken(token) {
+  state.token = token;
+}
+function getApiToken() {
+  return state.token;
+}
+
+// src/client/error-codes.ts
+var HTTP_STATUS_MAP = {
+  200: "\u8BF7\u6C42\u6210\u529F",
+  400: "\u53C2\u6570\u5217\u8868\u9519\u8BEF",
+  401: "\u672A\u6388\u6743",
+  403: "\u8BBF\u95EE\u53D7\u9650\uFF0C\u6388\u6743\u8FC7\u671F",
+  404: "\u8D44\u6E90\u6216\u670D\u52A1\u672A\u627E\u5230",
+  405: "\u4E0D\u5141\u8BB8\u7684HTTP\u65B9\u6CD5",
+  408: "\u8BF7\u6C42\u8D85\u65F6",
+  500: "\u7CFB\u7EDF\u5185\u90E8\u9519\u8BEF",
+  501: "\u672A\u5B9E\u73B0",
+  503: "\u670D\u52A1\u4E0D\u53EF\u7528"
+};
+var BUSINESS_ERROR_MAP = {
+  // 系统级错误 (1YYZZ)
+  "10000": "\u7CFB\u7EDF\u5185\u90E8\u9519\u8BEF",
+  "10001": "\u6570\u636E\u5E93\u64CD\u4F5C\u5931\u8D25",
+  "10002": "\u7F13\u5B58\u670D\u52A1\u5F02\u5E38",
+  "10003": "\u914D\u7F6E\u6587\u4EF6\u9519\u8BEF",
+  "10004": "\u670D\u52A1\u521D\u59CB\u5316\u5931\u8D25",
+  "10005": "\u7CFB\u7EDF\u8D44\u6E90\u4E0D\u8DB3",
+  "10006": "\u7EBF\u7A0B\u6C60\u5F02\u5E38",
+  "10007": "\u6D88\u606F\u961F\u5217\u5F02\u5E38",
+  "10008": "\u670D\u52A1\u95F4\u901A\u4FE1\u5931\u8D25",
+  "10009": "\u6570\u636E\u5E8F\u5217\u5316\u5931\u8D25",
+  "10010": "\u6570\u636E\u53CD\u5E8F\u5217\u5316\u5931\u8D25",
+  // 客户端参数错误 (2YYZZ)
+  "20000": "\u901A\u7528\u53C2\u6570\u9519\u8BEF",
+  "20001": "\u5FC5\u586B\u53C2\u6570\u7F3A\u5931",
+  "20002": "\u53C2\u6570\u683C\u5F0F\u9519\u8BEF",
+  "20003": "\u53C2\u6570\u7C7B\u578B\u4E0D\u5339\u914D",
+  "20004": "\u53C2\u6570\u503C\u8D85\u51FA\u8303\u56F4",
+  "20005": "\u53C2\u6570\u6821\u9A8C\u5931\u8D25",
+  "20006": "JSON\u89E3\u6790\u5931\u8D25",
+  "20007": "XML\u89E3\u6790\u5931\u8D25",
+  "20008": "\u53C2\u6570\u957F\u5EA6\u8D85\u9650",
+  "20009": "\u65E0\u6548\u7684\u679A\u4E3E\u503C",
+  "20010": "\u53C2\u6570\u7EC4\u5408\u65E0\u6548",
+  "20011": "\u8BF7\u6C42\u4F53\u8FC7\u5927",
+  "20012": "\u65F6\u95F4\u53C2\u6570\u683C\u5F0F\u9519\u8BEF",
+  // 认证授权错误 (3YYZZ)
+  "30001": "\u7528\u6237\u540D\u4E0D\u5B58\u5728",
+  "30002": "\u5BC6\u7801\u9519\u8BEF",
+  "30003": "\u7528\u6237\u8D26\u53F7\u5DF2\u7981\u7528",
+  "30004": "\u7528\u6237\u8D26\u53F7\u5DF2\u9501\u5B9A",
+  "30005": "\u767B\u5F55\u5C1D\u8BD5\u6B21\u6570\u8D85\u9650",
+  "30006": "\u4F1A\u8BDD\u5DF2\u8FC7\u671F",
+  "30007": "\u4EE4\u724C\u65E0\u6548",
+  "30008": "\u4EE4\u724C\u5DF2\u8FC7\u671F",
+  "30009": "\u5237\u65B0\u4EE4\u724C\u65E0\u6548",
+  "30010": "\u6743\u9650\u4E0D\u8DB3",
+  "30011": "\u89D2\u8272\u4E0D\u5B58\u5728",
+  "30012": "\u8BBF\u95EEIP\u53D7\u9650",
+  "30013": "\u8BBF\u95EE\u65F6\u95F4\u53D7\u9650",
+  "30014": "\u53CC\u56E0\u7D20\u8BA4\u8BC1\u5931\u8D25",
+  "30015": "\u7528\u6237\u540D\u4E0D\u80FD\u4E3A\u7A7A",
+  "30016": "\u5BC6\u7801\u4E0D\u80FD\u4E3A\u7A7A",
+  "30017": "\u7528\u6237\u540D\u5DF2\u7ECF\u5B58\u5728",
+  "30018": "\u7528\u6237\u540D\u9000\u51FA\u5931\u8D25",
+  // 业务逻辑错误 (4YYZZ)
+  // 403ZZ: 航线管理
+  "40300": "\u822A\u7EBF\u64CD\u4F5C\u5931\u8D25",
+  "40301": "\u822A\u7EBFID\u5DF2\u5B58\u5728",
+  "40302": "\u822A\u7EBF\u4E0D\u5B58\u5728",
+  "40303": "\u822A\u7EBF\u540D\u79F0\u91CD\u590D",
+  "40304": "\u822A\u7EBF\u6570\u636E\u65E0\u6548",
+  "40305": "\u822A\u70B9\u5217\u8868\u4E3A\u7A7A",
+  "40306": "\u822A\u70B9\u6570\u91CF\u8D85\u9650",
+  "40307": "\u822A\u70B9\u5E8F\u53F7\u4E0D\u8FDE\u7EED",
+  "40308": "\u822A\u70B9\u7C7B\u578B\u4E0D\u5408\u6CD5\uFF08\u5141\u8BB8\u503C\uFF1A0/1/2\uFF09",
+  "40309": "\u7ECF\u7EAC\u5EA6\u683C\u5F0F\u9519\u8BEF",
+  "40310": "\u7ECF\u7EAC\u5EA6\u8D85\u51FA\u8303\u56F4",
+  "40311": "\u9AD8\u5EA6\u503C\u975E\u6CD5",
+  "40312": "\u901F\u5EA6\u503C\u975E\u6CD5",
+  "40313": "\u5207\u6362\u6A21\u5F0F\u4E0D\u5408\u6CD5",
+  "40314": "\u822A\u7EBF\u603B\u8DDD\u79BB\u8D85\u9650",
+  "40315": "\u822A\u7EBF\u4FDD\u5B58\u5931\u8D25",
+  "40316": "\u822A\u7EBF\u5220\u9664\u5931\u8D25",
+  "40317": "\u822A\u7EBF\u590D\u5236\u5931\u8D25",
+  "40318": "\u822A\u7EBF\u5BFC\u5165\u5931\u8D25",
+  "40319": "\u822A\u7EBF\u5BFC\u51FA\u5931\u8D25",
+  "40320": "\u822A\u7EBF\u6267\u884C\u51B2\u7A81\uFF08\u6B63\u5728\u6267\u884C\uFF09",
+  // 404ZZ: 电子围栏
+  "40400": "\u56F4\u680F\u64CD\u4F5C\u5931\u8D25",
+  "40401": "\u56F4\u680F\u540D\u79F0\u91CD\u590D",
+  "40402": "\u56F4\u680F\u4E0D\u5B58\u5728",
+  "40403": "\u51E0\u4F55\u7C7B\u578B\u4E0D\u5408\u6CD5\uFF080=\u591A\u8FB9\u5F62\uFF0C1=\u5706\u5F62\uFF0C2=\u6247\u533A\uFF09",
+  "40404": "\u7A7A\u57DF\u5C5E\u6027\u4E0D\u5408\u6CD5\uFF080=\u7981\u98DE\uFF0C1=\u8B66\u544A\uFF0C2=\u9650\u9AD8\uFF0C3=\u7BA1\u5236\uFF09",
+  "40405": "\u591A\u8FB9\u5F62\u9876\u70B9\u6570\u4E0D\u8DB3\uFF08\u81F3\u5C113\u4E2A\uFF09",
+  "40406": "\u9876\u70B9\u5750\u6807\u683C\u5F0F\u9519\u8BEF",
+  "40407": "\u9876\u70B9\u5E8F\u53F7\u4E0D\u8FDE\u7EED",
+  "40408": "\u591A\u8FB9\u5F62\u81EA\u76F8\u4EA4",
+  "40409": "\u5706\u5F62\u534A\u5F84\u975E\u6CD5",
+  "40410": "\u6247\u533A\u534A\u5F84\u975E\u6CD5",
+  "40411": "\u8D77\u59CB\u65B9\u5411\u4E0D\u5408\u6CD5\uFF080-360\uFF09",
+  "40412": "\u7ED3\u675F\u65B9\u5411\u4E0D\u5408\u6CD5\uFF080-360\uFF09",
+  "40413": "\u65F6\u95F4\u8303\u56F4\u91CD\u53E0",
+  "40414": "\u76F8\u5BF9\u9AD8\u5EA6\u975E\u6CD5",
+  "40415": "\u56F4\u680F\u7A7A\u95F4\u51B2\u7A81\uFF08\u4E0E\u73B0\u6709\u56F4\u680F\u91CD\u53E0\uFF09",
+  // 405ZZ: 实时数据
+  "40500": "\u5B9E\u65F6\u6570\u636E\u9519\u8BEF",
+  "40501": "\u6570\u636E\u6D41\u4E0D\u5B58\u5728",
+  "40502": "\u6570\u636E\u8BA2\u9605\u5931\u8D25",
+  "40503": "\u6570\u636E\u53D1\u5E03\u5931\u8D25",
+  "40504": "\u6570\u636E\u683C\u5F0F\u9519\u8BEF",
+  "40505": "\u6570\u636E\u89E3\u6790\u5931\u8D25",
+  "40506": "\u65F6\u95F4\u6233\u65E0\u6548",
+  "40507": "\u6570\u636E\u8FC7\u671F",
+  "40508": "\u6570\u636E\u9891\u7387\u8D85\u9650",
+  "40509": "\u6570\u636E\u91CF\u8FC7\u5927",
+  "40510": "\u6570\u636E\u6D41\u4E2D\u65AD",
+  "40511": "\u6570\u636E\u7C7B\u578B\u4E0D\u652F\u6301",
+  "40512": "\u6570\u636E\u9A8C\u8BC1\u5931\u8D25",
+  // 文件/媒体错误 (7YYZZ)
+  // 706ZZ: 视频流
+  "70600": "\u89C6\u9891\u6D41\u9519\u8BEF",
+  "70601": "\u89C6\u9891\u6D41\u4E0D\u5B58\u5728\u6216\u672A\u5F00\u542F",
+  "70602": "\u89C6\u9891\u6D41\u6743\u9650\u4E0D\u8DB3",
+  "70603": "\u89C6\u9891\u7F16\u7801\u683C\u5F0F\u4E0D\u652F\u6301\uFF08\u652F\u6301\uFF1AH.264, H.265, VP9\uFF09",
+  "70604": "\u89C6\u9891\u5206\u8FA8\u7387\u4E0D\u652F\u6301",
+  "70605": "\u89C6\u9891\u5E27\u7387\u5F02\u5E38\uFF08\u8303\u56F4\uFF1A1-60fps\uFF09",
+  "70606": "\u89C6\u9891\u6D41\u8FDE\u63A5\u5931\u8D25\uFF08RTSP/WebRTC\uFF09",
+  "70607": "\u89C6\u9891\u6D41\u4E2D\u65AD",
+  "70608": "\u89C6\u9891\u89E3\u7801\u5931\u8D25",
+  "70609": "\u89C6\u9891\u7F13\u51B2\u8D85\u65F6",
+  "70610": "\u89C6\u9891\u6D41\u4F1A\u8BDD\u8D85\u9650\uFF08\u6BCF\u7EC8\u7AEF\u6700\u591AX\u8DEF\uFF09",
+  "70611": "\u89C6\u9891\u5B58\u50A8\u5931\u8D25",
+  "70612": "\u89C6\u9891\u65F6\u95F4\u6233\u5F02\u5E38",
+  "70613": "\u89C6\u9891\u7801\u7387\u5F02\u5E38",
+  "70614": "\u89C6\u9891\u5173\u952E\u5E27\u4E22\u5931",
+  "70615": "\u89C6\u9891\u6C34\u5370\u6DFB\u52A0\u5931\u8D25",
+  // 707ZZ: 音频流
+  "70700": "\u97F3\u9891\u6D41\u9519\u8BEF",
+  "70701": "\u97F3\u9891\u6D41\u4E0D\u5B58\u5728\u6216\u672A\u5F00\u542F",
+  "70702": "\u97F3\u9891\u6D41\u6743\u9650\u4E0D\u8DB3",
+  "70703": "\u97F3\u9891\u7F16\u7801\u683C\u5F0F\u4E0D\u652F\u6301\uFF08\u652F\u6301\uFF1AAAC, MP3, Opus\uFF09",
+  "70704": "\u97F3\u9891\u91C7\u6837\u7387\u4E0D\u652F\u6301",
+  "70705": "\u97F3\u9891\u58F0\u9053\u6570\u4E0D\u652F\u6301\uFF08\u652F\u6301\uFF1A\u5355\u58F0\u9053/\u7ACB\u4F53\u58F0\uFF09",
+  "70706": "\u97F3\u9891\u6D41\u8FDE\u63A5\u5931\u8D25",
+  "70707": "\u97F3\u9891\u6D41\u4E2D\u65AD",
+  "70708": "\u97F3\u9891\u89E3\u7801\u5931\u8D25",
+  "70709": "\u97F3\u9891\u91C7\u96C6\u8BBE\u5907\u5F02\u5E38",
+  "70710": "\u97F3\u9891\u64AD\u653E\u8BBE\u5907\u5F02\u5E38",
+  "70711": "\u97F3\u9891\u964D\u566A\u5931\u8D25",
+  "70712": "\u97F3\u9891\u56DE\u58F0\u6D88\u9664\u5931\u8D25",
+  "70713": "\u97F3\u9891\u6BD4\u7279\u7387\u5F02\u5E38",
+  // 708ZZ: 流媒体服务
+  "70800": "\u6D41\u5A92\u4F53\u670D\u52A1\u9519\u8BEF",
+  "70801": "\u6D41\u5A92\u4F53\u670D\u52A1\u5668\u4E0D\u53EF\u7528",
+  "70802": "\u7F51\u7EDC\u5E26\u5BBD\u4E0D\u8DB3",
+  "70803": "\u7F51\u7EDC\u5EF6\u8FDF\u8FC7\u9AD8\uFF08>300ms\uFF09",
+  "70804": "\u7F51\u7EDC\u4E22\u5305\u4E25\u91CD\uFF08>5%\uFF09",
+  "70805": "\u6D41\u5A92\u4F53\u534F\u8BAE\u4E0D\u652F\u6301",
+  "70806": "\u6D41\u5A92\u4F53\u4F1A\u8BDD\u8FC7\u671F",
+  "70807": "\u6D41\u5A92\u4F53\u4F1A\u8BDD\u51B2\u7A81",
+  "70808": "\u8F6C\u7801\u670D\u52A1\u5931\u8D25",
+  "70809": "\u5408\u6D41\u670D\u52A1\u5931\u8D25",
+  "70810": "\u5F55\u5236\u670D\u52A1\u5931\u8D25",
+  // 709ZZ: 音视频控制
+  "70900": "\u97F3\u89C6\u9891\u63A7\u5236\u9519\u8BEF",
+  "70901": "\u5F00\u59CB\u63A8\u6D41\u5931\u8D25",
+  "70902": "\u505C\u6B62\u63A8\u6D41\u5931\u8D25",
+  "70903": "\u5207\u6362\u7801\u7387\u5931\u8D25",
+  "70904": "\u5207\u6362\u5206\u8FA8\u7387\u5931\u8D25",
+  "70905": "\u9759\u97F3\u64CD\u4F5C\u5931\u8D25",
+  "70906": "\u53D6\u6D88\u9759\u97F3\u5931\u8D25",
+  "70907": "\u5F00\u59CB\u5F55\u50CF\u5931\u8D25",
+  "70908": "\u505C\u6B62\u5F55\u50CF\u5931\u8D25",
+  "70909": "\u89C6\u9891\u6293\u62CD\u5931\u8D25",
+  "70910": "\u4E91\u53F0\u63A7\u5236\u5931\u8D25",
+  "70911": "\u955C\u5934\u53D8\u7126\u5931\u8D25",
+  "70912": "\u7126\u70B9\u8C03\u6574\u5931\u8D25",
+  "70913": "\u767D\u5E73\u8861\u8C03\u6574\u5931\u8D25",
+  // 710ZZ: 日志文件
+  "71000": "\u6587\u4EF6\u64CD\u4F5C\u9519\u8BEF",
+  "71001": "\u6587\u4EF6\u53C2\u6570\u7F3A\u5931",
+  "71002": "\u6587\u4EF6\u683C\u5F0F\u4E0D\u652F\u6301",
+  "71003": "\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25",
+  "71004": "\u6587\u4EF6\u89E3\u6790\u5931\u8D25",
+  "71005": "\u6587\u4EF6\u5927\u5C0F\u8D85\u9650\uFF08\u6700\u5927\uFF1A100MB\uFF09",
+  "71006": "\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25",
+  "71007": "\u6587\u4EF6\u4E0B\u8F7D\u5931\u8D25",
+  "71008": "\u6587\u4EF6\u5220\u9664\u5931\u8D25",
+  "71009": "\u6587\u4EF6\u6821\u9A8C\u5931\u8D25\uFF08MD5/SHA\uFF09",
+  "71010": "\u6587\u4EF6\u538B\u7F29\u5931\u8D25",
+  "71011": "\u6587\u4EF6\u89E3\u538B\u5931\u8D25",
+  "71012": "\u5B58\u50A8\u7A7A\u95F4\u4E0D\u8DB3",
+  // 设备硬件错误 (8YYZZ)
+  // 802ZZ: 自检维护
+  "80200": "\u81EA\u68C0\u7EF4\u62A4\u9519\u8BEF",
+  "80201": "\u9065\u63A7\u7AD9\u81EA\u68C0\u53C2\u6570\u7F3A\u5931",
+  "80202": "\u9065\u63A7\u7AD9\u81EA\u68C0\u53C2\u6570\u9519\u8BEF",
+  "80203": "\u673A\u4E0A\u7CFB\u7EDF\u81EA\u68C0\u53C2\u6570\u7F3A\u5931",
+  "80204": "\u673A\u4E0A\u7CFB\u7EDF\u81EA\u68C0\u53C2\u6570\u9519\u8BEF",
+  "80205": "\u7EF4\u62A4\u6307\u4EE4\u53C2\u6570\u7F3A\u5931",
+  "80206": "\u7EF4\u62A4\u6307\u4EE4\u53C2\u6570\u9519\u8BEF",
+  "80207": "\u81EA\u68C0\u8D85\u65F6\uFF08>30\u79D2\uFF09",
+  "80208": "\u81EA\u68C0\u5931\u8D25\uFF08\u786C\u4EF6\u5F02\u5E38\uFF09",
+  "80209": "GPS\u6A21\u5757\u5F02\u5E38",
+  "80210": "IMU\u4F20\u611F\u5668\u5F02\u5E38",
+  "80211": "\u6C14\u538B\u8BA1\u5F02\u5E38",
+  "80212": "\u78C1\u529B\u8BA1\u5F02\u5E38",
+  "80213": "\u7535\u6C60\u72B6\u6001\u5F02\u5E38",
+  "80214": "\u7535\u673A\u72B6\u6001\u5F02\u5E38",
+  "80215": "\u901A\u4FE1\u6A21\u5757\u5F02\u5E38",
+  "80216": "\u98DE\u63A7\u7CFB\u7EDF\u5F02\u5E38",
+  "80217": "\u56FA\u4EF6\u7248\u672C\u4E0D\u5339\u914D"
+};
+var ErrorLevel2 = /* @__PURE__ */ ((ErrorLevel3) => {
+  ErrorLevel3[ErrorLevel3["SUCCESS"] = 0] = "SUCCESS";
+  ErrorLevel3[ErrorLevel3["SYSTEM"] = 1] = "SYSTEM";
+  ErrorLevel3[ErrorLevel3["CLIENT_PARAM"] = 2] = "CLIENT_PARAM";
+  ErrorLevel3[ErrorLevel3["AUTH"] = 3] = "AUTH";
+  ErrorLevel3[ErrorLevel3["BUSINESS"] = 4] = "BUSINESS";
+  ErrorLevel3[ErrorLevel3["RESOURCE"] = 5] = "RESOURCE";
+  ErrorLevel3[ErrorLevel3["NETWORK"] = 6] = "NETWORK";
+  ErrorLevel3[ErrorLevel3["FILE_MEDIA"] = 7] = "FILE_MEDIA";
+  ErrorLevel3[ErrorLevel3["DEVICE_HARDWARE"] = 8] = "DEVICE_HARDWARE";
+  ErrorLevel3[ErrorLevel3["THIRD_PARTY"] = 9] = "THIRD_PARTY";
+  return ErrorLevel3;
+})(ErrorLevel2 || {});
+var FunctionModule2 = /* @__PURE__ */ ((FunctionModule4) => {
+  FunctionModule4["GENERAL"] = "00";
+  FunctionModule4["USER_AUTH"] = "01";
+  FunctionModule4["SELF_CHECK"] = "02";
+  FunctionModule4["AIRLINE"] = "03";
+  FunctionModule4["FENCE"] = "04";
+  FunctionModule4["REAL_TIME_DATA"] = "05";
+  FunctionModule4["VIDEO_STREAM"] = "06";
+  FunctionModule4["AUDIO_STREAM"] = "07";
+  FunctionModule4["MEDIA_SERVICE"] = "08";
+  FunctionModule4["AV_CONTROL"] = "09";
+  FunctionModule4["LOG_FILE"] = "10";
+  FunctionModule4["REMOTE_CONTROL"] = "11";
+  FunctionModule4["FLIGHT_STATUS"] = "12";
+  return FunctionModule4;
+})(FunctionModule2 || {});
+function resolveBusinessError(subCode) {
+  if (!subCode) return "\u4E1A\u52A1\u9519\u8BEF";
+  const codeStr = String(subCode);
+  return BUSINESS_ERROR_MAP[codeStr] || "\u672A\u77E5\u4E1A\u52A1\u9519\u8BEF";
+}
+function resolveHttpStatus(status) {
+  if (!status) return "\u672A\u77E5\u72B6\u6001";
+  return HTTP_STATUS_MAP[status] || "\u672A\u77E5HTTP\u72B6\u6001";
+}
+function resolveErrorLevel(subCode) {
+  if (!subCode) return 4 /* BUSINESS */;
+  const codeStr = String(subCode);
+  const level = parseInt(codeStr[0], 10);
+  return Object.values(ErrorLevel2).includes(level) ? level : 4 /* BUSINESS */;
+}
+function resolveFunctionModule(subCode) {
+  if (!subCode) return "00" /* GENERAL */;
+  const codeStr = String(subCode);
+  if (codeStr.length < 3) return "00" /* GENERAL */;
+  const module = codeStr.slice(1, 3);
+  return Object.values(FunctionModule2).includes(module) ? module : "00" /* GENERAL */;
+}
+
+// src/client/http.ts
+var notifiedErrors = /* @__PURE__ */ new WeakSet();
+function pickMsg(r) {
+  var _a, _b;
+  return (_b = (_a = r.msg) != null ? _a : r.message) != null ? _b : "";
+}
+function notifyError(config, error) {
+  var _a;
+  try {
+    if (notifiedErrors.has(error)) return;
+    notifiedErrors.add(error);
+    if (config.debug) {
+      const raw = error.raw;
+      handleHttpLog(config, "ERROR", {
+        name: "ApiError",
+        url: typeof raw === "object" && raw !== null && "url" in raw ? String(raw.url) : void 0,
+        method: typeof raw === "object" && raw !== null && "method" in raw ? String(raw.method) : void 0,
+        response: {
+          code: error.code || error.httpStatus || 500,
+          message: error.message,
+          error: error.type,
+          sub_code: error.subCode,
+          sub_msg: error.subMsg
+        },
+        status: error.httpStatus,
+        request: typeof raw === "object" && raw !== null && ("request" in raw || "data" in raw) ? raw.request || raw.data : void 0,
+        headers: typeof raw === "object" && raw !== null && "headers" in raw ? raw.headers : void 0
+      });
+    }
+    (_a = config.onError) == null ? void 0 : _a.call(config, error);
+  } catch {
+    return;
+  }
+}
+function simulateNext401(count = 1) {
+  state.simulate401Remaining = count;
+}
+function resolveBusinessMessage(config, data) {
+  var _a, _b;
+  const key = (_a = data.sub_code) != null ? _a : data.code;
+  if (key !== void 0) {
+    const mapped = (_b = config.businessErrorMessageMap) == null ? void 0 : _b[key];
+    if (mapped) return mapped;
+  }
+  const businessMsg = resolveBusinessError(data.sub_code);
+  if (businessMsg !== "\u4E1A\u52A1\u9519\u8BEF") return businessMsg;
+  return pickMsg(data) || "\u4E1A\u52A1\u9519\u8BEF";
+}
+function isRefreshRequest(cfg) {
+  var _a;
+  const url = (_a = cfg == null ? void 0 : cfg.url) != null ? _a : "";
+  return url.includes("/auth/v1/refresh");
+}
+function parseQueryFromUrl(url) {
+  const idx = url.indexOf("?");
+  if (idx < 0) return {};
+  const qs = url.slice(idx + 1);
+  if (!qs) return {};
+  const out = {};
+  for (const part of qs.split("&")) {
+    if (!part) continue;
+    const eq = part.indexOf("=");
+    if (eq < 0) {
+      out[decodeURIComponent(part)] = "";
+      continue;
+    }
+    const k = decodeURIComponent(part.slice(0, eq));
+    const v = decodeURIComponent(part.slice(eq + 1));
+    out[k] = v;
+  }
+  return out;
+}
+function setHeader(cfg, key, value) {
+  if (!cfg.headers) cfg.headers = new axios.AxiosHeaders();
+  const headers = cfg.headers;
+  const headerSetter = headers;
+  if (typeof headerSetter.set === "function") {
+    headerSetter.set(key, value);
+    return;
+  }
+  cfg.headers[key] = value;
+}
+var isRefreshing = false;
+var refreshPromise;
+var pending = [];
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function refreshTokenWithRetry(instance, config) {
+  var _a;
+  const maxRetries = (_a = config.tokenRefreshMaxRetries) != null ? _a : 1;
+  let retryCount = 0;
+  while (true) {
+    try {
+      return await refreshToken(instance, config);
+    } catch (e) {
+      if (e instanceof ApiError && e.message.includes("\u672A\u8BBE\u7F6E token")) throw e;
+      retryCount += 1;
+      const shouldRetry = maxRetries === 0 || retryCount <= maxRetries;
+      if (!shouldRetry) throw e;
+      await sleep(500);
+    }
+  }
+}
+async function refreshAndReplay(instance, config, cfg) {
+  cfg._retry = true;
+  if (isRefreshing) {
+    return new Promise((resolve, reject) => {
+      pending.push({ resolve, reject, config: cfg });
+    }).then(() => instance.request(cfg));
+  }
+  isRefreshing = true;
+  refreshPromise = refreshTokenWithRetry(instance, config);
+  try {
+    await refreshPromise;
+    for (const p of pending.splice(0, pending.length)) {
+      p.resolve();
+    }
+    return instance.request(cfg);
+  } catch (e) {
+    for (const p of pending.splice(0, pending.length)) {
+      p.reject(e);
+    }
+    throw e;
+  } finally {
+    isRefreshing = false;
+    refreshPromise = void 0;
+  }
+}
+async function refreshToken(instance, config) {
+  var _a, _b, _c, _d, _e;
+  handleHttpLog(config, "INFO", {
+    name: "refreshToken",
+    url: `${config.baseUrl}/auth/v1/refresh`,
+    method: "POST"});
+  const token = getApiToken();
+  if (!token) {
+    const error = new ApiError({ message: "\u672A\u8BBE\u7F6E token\uFF0C\u65E0\u6CD5\u5237\u65B0", type: "auth" });
+    handleHttpLog(config, "ERROR", {
+      name: "refreshToken",
+      url: `${config.baseUrl}/auth/v1/refresh`,
+      method: "POST"});
+    throw error;
+  }
+  handleHttpLog(config, "DEBUG", {
+    name: "refreshToken",
+    url: `${config.baseUrl}/auth/v1/refresh`,
+    method: "POST",
+    request: {}
+  });
+  const res = await instance.request({
+    url: "/auth/v1/refresh",
+    method: "POST",
+    data: {}
+  });
+  if (!res.data || res.data.code !== 200 || !((_a = res.data.data) == null ? void 0 : _a.token)) {
+    const error = new ApiError({
+      message: pickMsg((_b = res.data) != null ? _b : {}) || "\u5237\u65B0 token \u5931\u8D25",
+      type: "auth",
+      httpStatus: res.status,
+      code: (_c = res.data) == null ? void 0 : _c.code,
+      subCode: (_d = res.data) == null ? void 0 : _d.sub_code,
+      subMsg: (_e = res.data) == null ? void 0 : _e.sub_msg,
+      raw: res.data
+    });
+    handleHttpLog(config, "ERROR", {
+      name: "refreshToken",
+      url: `${config.baseUrl}/auth/v1/refresh`,
+      method: "POST",
+      response: res.data,
+      status: res.status,
+      request: {},
+      headers: res.config.headers
+    });
+    throw error;
+  }
+  const newToken = res.data.data.token;
+  setApiToken(newToken);
+  handleHttpLog(config, "INFO", {
+    name: "refreshToken",
+    url: `${config.baseUrl}/auth/v1/refresh`,
+    method: "POST",
+    response: res.data,
+    status: res.status
+  });
+  return newToken;
+}
+function createHttpClient(config) {
+  const instance = axios__default.default.create({
+    baseURL: config.baseUrl
+  });
+  instance.interceptors.request.use(async (cfg) => {
+    var _a, _b, _c, _d, _e, _f;
+    const c = cfg;
+    if (isRefreshing && refreshPromise && !isRefreshRequest(c)) {
+      await refreshPromise;
+    }
+    c.metadata = { startTime: Date.now(), apiName: (_a = c.metadata) == null ? void 0 : _a.apiName };
+    handleHttpLog(config, "DEBUG", {
+      name: ((_b = c.metadata) == null ? void 0 : _b.apiName) || "request",
+      url: `${config.baseUrl}${c.url || ""}`,
+      method: c.method || "",
+      headers: c.headers,
+      request: c.data || c.params
+    });
+    const timestamp = Date.now();
+    const nonce = randomNonce(32);
+    setHeader(c, "X-Timestamp", timestamp);
+    setHeader(c, "X-Nonce", nonce);
+    const token = getApiToken();
+    if (token) setHeader(c, "Authorization", token);
+    const rawUrl = (_c = c.url) != null ? _c : "";
+    const uri = rawUrl.split("?")[0];
+    const paramsFromUrl = parseQueryFromUrl(rawUrl);
+    const mergedQuery = {
+      ...paramsFromUrl,
+      ...(_d = c.params) != null ? _d : {}
+    };
+    handleHttpLog(config, "TRACE", {
+      name: ((_e = c.metadata) == null ? void 0 : _e.apiName) || "generate-sign",
+      url: `${config.baseUrl}${c.url || ""}`,
+      method: c.method || "",
+      request: {
+        timestamp,
+        nonce,
+        uri,
+        query: mergedQuery,
+        method: c.method || "GET"
+      }
+    });
+    const { sign } = generateSign({
+      uri,
+      timestamp,
+      nonce,
+      query: mergedQuery,
+      body: c.data,
+      secret: config.secret,
+      salt: config.salt
+    });
+    setHeader(c, "X-Sign", sign);
+    handleHttpLog(config, "TRACE", {
+      name: ((_f = c.metadata) == null ? void 0 : _f.apiName) || "generate-sign",
+      url: `${config.baseUrl}${c.url || ""}`,
+      method: c.method || ""
+    });
+    return c;
+  });
+  instance.interceptors.response.use(
+    // 成功响应处理
+    async (resp) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      const cfg = resp.config;
+      const durationMs = cfg.metadata ? Date.now() - cfg.metadata.startTime : void 0;
+      const apiName = (_b = (_a = cfg.metadata) == null ? void 0 : _a.apiName) != null ? _b : "request";
+      const data = resp.data;
+      if (typeof data === "object" && data && "code" in data) {
+        const shouldSimulateAuth = ((_c = state.simulate401Remaining) != null ? _c : 0) > 0 && !cfg._retry && !isRefreshRequest(cfg);
+        if (shouldSimulateAuth) {
+          state.simulate401Remaining = ((_d = state.simulate401Remaining) != null ? _d : 1) - 1;
+        }
+        const normalizedData = shouldSimulateAuth ? { ...data, code: 401 } : data;
+        const httpLog = {
+          name: apiName,
+          url: `${config.baseUrl}${(_e = cfg.url) != null ? _e : ""}`,
+          method: cfg.method,
+          headers: cfg.headers,
+          request: (_f = cfg.data) != null ? _f : cfg.params,
+          response: shouldSimulateAuth ? normalizedData : resp.data,
+          durationMs,
+          status: resp.status
+        };
+        if ((normalizedData.code === 401 || normalizedData.code === 403) && !cfg._retry && !isRefreshRequest(cfg)) {
+          handleHttpLog(config, "WARN", httpLog);
+          return await refreshAndReplay(instance, config, cfg);
+        }
+        if (normalizedData.code !== 200) {
+          const errorLevel = resolveErrorLevel(normalizedData.sub_code);
+          const module = resolveFunctionModule(normalizedData.sub_code);
+          const e = new ApiError({
+            message: resolveBusinessMessage(config, normalizedData),
+            type: normalizedData.code === 401 || normalizedData.code === 403 ? "auth" : "business",
+            httpStatus: resp.status,
+            code: normalizedData.code,
+            subCode: normalizedData.sub_code,
+            subMsg: normalizedData.sub_msg,
+            errorLevel,
+            module,
+            raw: {
+              ...normalizedData,
+              url: `${config.baseUrl}${(_g = cfg.url) != null ? _g : ""}`,
+              method: cfg.method,
+              headers: cfg.headers,
+              request: (_h = cfg.data) != null ? _h : cfg.params,
+              durationMs: cfg.metadata ? Date.now() - cfg.metadata.startTime : void 0
+            }
+          });
+          notifyError(config, e);
+          throw e;
+        }
+        handleHttpLog(config, "INFO", httpLog);
+      }
+      return resp;
+    },
+    // 错误响应处理
+    async (error) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+      if (error instanceof ApiError) {
+        notifyError(config, error);
+        throw error;
+      }
+      const axiosErr = error;
+      const cfg = (_a = axiosErr.config) != null ? _a : {};
+      const status = (_b = axiosErr.response) == null ? void 0 : _b.status;
+      const url = `${config.baseUrl}${(_c = cfg.url) != null ? _c : ""}`;
+      const method = (_d = cfg.method) != null ? _d : "";
+      const request = (_e = cfg.data) != null ? _e : cfg.params;
+      const response = (_f = axiosErr.response) == null ? void 0 : _f.data;
+      const durationMs = cfg.metadata ? Date.now() - cfg.metadata.startTime : void 0;
+      const apiName = (_h = (_g = cfg.metadata) == null ? void 0 : _g.apiName) != null ? _h : "request";
+      const httpLog = {
+        name: apiName,
+        url,
+        method,
+        headers: cfg.headers,
+        request,
+        response,
+        durationMs};
+      handleHttpLog(config, "ERROR", httpLog);
+      if ((status === 401 || status === 403) && !cfg._retry && !isRefreshRequest(cfg)) {
+        return await refreshAndReplay(instance, config, cfg);
+      }
+      if (axiosErr.response) {
+        const httpStatusText = resolveHttpStatus(status);
+        let message = `${httpStatusText}(${status})`;
+        let subCode;
+        let subMsg;
+        let errorLevel;
+        let module;
+        if (axiosErr.response.data && typeof axiosErr.response.data === "object") {
+          const data = axiosErr.response.data;
+          subCode = data.sub_code;
+          subMsg = data.sub_msg || data.msg || data.message;
+          if (subCode) {
+            errorLevel = resolveErrorLevel(subCode);
+            module = resolveFunctionModule(subCode);
+            const businessMsg = resolveBusinessError(subCode);
+            message = businessMsg;
+          }
+        }
+        const e2 = new ApiError({
+          message,
+          type: status === 401 || status === 403 ? "auth" : "server",
+          httpStatus: status,
+          subCode,
+          subMsg,
+          errorLevel,
+          module,
+          raw: axiosErr.response.data
+        });
+        notifyError(config, e2);
+        throw e2;
+      }
+      if (axiosErr.request) {
+        const e2 = new ApiError({
+          message: "\u7F51\u7EDC\u9519\u8BEF",
+          type: "network",
+          errorLevel: 6 /* NETWORK */,
+          raw: (_i = axiosErr.toJSON) == null ? void 0 : _i.call(axiosErr)
+        });
+        notifyError(config, e2);
+        throw e2;
+      }
+      const e = new ApiError({
+        message: axiosErr.message || "\u672A\u77E5\u9519\u8BEF",
+        type: "unknown",
+        raw: (_j = axiosErr.toJSON) == null ? void 0 : _j.call(axiosErr)
+      });
+      notifyError(config, e);
+      throw e;
+    }
+  );
+  return instance;
+}
+function initApiClient(config) {
+  state.config = config;
+  state.axios = createHttpClient(config);
+}
+function getHttpClient() {
+  if (!state.axios) {
+    const error = new ApiError({ message: "Api Client \u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 initApiClient", type: "unknown" });
+    handleHttpLog({
+      baseUrl: window.location.origin,
+      secret: "undefined",
+      salt: "undefined",
+      debug: true,
+      logLevel: "ERROR"
+    }, "ERROR", {
+      name: "getHttpClient",
+      response: {
+        code: null,
+        message: error.message,
+        error: error.type
+      }
+    });
+    throw error;
+  }
+  return state.axios;
+}
+async function requestData(cfg, apiName) {
+  var _a, _b;
+  const instance = getHttpClient();
+  const c = cfg;
+  c.metadata = { ...(_a = c.metadata) != null ? _a : { startTime: Date.now() }, apiName };
+  const resp = await instance.request(c);
+  const data = resp.data;
+  return (_b = data == null ? void 0 : data.data) != null ? _b : {};
+}
+
+// src/api/v1/auth.ts
+var loginApi = async (req) => {
+  return requestData({
+    url: "/auth/v1/login",
+    method: "POST",
+    data: req
+  }, "login");
+};
+var refreshTokenApi = async (req) => {
+  return requestData({
+    url: "/auth/v1/refresh",
+    method: "POST",
+    data: req
+  }, "refreshToken");
+};
+var logoutApi = async (req) => {
+  return requestData({
+    url: "/auth/v1/logout",
+    method: "POST",
+    data: req
+  }, "logout");
+};
+
+// src/api/v1/airline.ts
+var airlineAddApi = async (req) => {
+  return requestData({
+    url: "/api/v1/airline/add",
+    method: "POST",
+    data: req
+  }, "airlineAdd");
+};
+var airlineListApi = async (req) => {
+  return requestData({
+    url: "/api/v1/airline/list",
+    method: "POST",
+    data: req
+  }, "airlineList");
+};
+var airlineQueryApi = async (req) => {
+  return requestData({
+    url: "/api/v1/airline/query",
+    method: "POST",
+    data: req
+  }, "airlineQuery");
+};
+var airlineUpdateApi = async (req) => {
+  return requestData({
+    url: "/api/v1/airline/update",
+    method: "POST",
+    data: req
+  }, "airlineUpdate");
+};
+
+// src/api/v1/fence.ts
+var fenceAddApi = async (req) => {
+  return requestData({
+    url: "/api/v1/fence/add",
+    method: "POST",
+    data: req
+  }, "fenceAdd");
+};
+var fenceListApi = async (req) => {
+  return requestData({
+    url: "/api/v1/fence/list",
+    method: "POST",
+    data: req
+  }, "fenceList");
+};
+var fenceQueryApi = async (req) => {
+  return requestData({
+    url: "/api/v1/fence/query",
+    method: "POST",
+    data: req
+  }, "fenceQuery");
+};
+var fenceUpdateApi = async (req) => {
+  return requestData({
+    url: "/api/v1/fence/update",
+    method: "POST",
+    data: req
+  }, "fenceUpdate");
+};
+
+exports.ApiError = ApiError;
+exports.ErrorLevel = ErrorLevel;
+exports.FunctionModule = FunctionModule;
+exports.airlineAddApi = airlineAddApi;
+exports.airlineListApi = airlineListApi;
+exports.airlineQueryApi = airlineQueryApi;
+exports.airlineUpdateApi = airlineUpdateApi;
+exports.fenceAddApi = fenceAddApi;
+exports.fenceListApi = fenceListApi;
+exports.fenceQueryApi = fenceQueryApi;
+exports.fenceUpdateApi = fenceUpdateApi;
+exports.getApiToken = getApiToken;
+exports.initApiClient = initApiClient;
+exports.loginApi = loginApi;
+exports.logoutApi = logoutApi;
+exports.refreshTokenApi = refreshTokenApi;
+exports.setApiToken = setApiToken;
+exports.simulateNext401 = simulateNext401;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map