web-dc-api 0.0.58 → 0.0.60

package/dist/esm/common/chain.js

@@ -0,0 +1,432 @@
+import { multiaddr } from '@multiformats/multiaddr';
+import { WsProvider, ApiPromise } from '@polkadot/api';
+import { isUser, hexToAscii, sha256 } from '../util/utils.js';
+import { PeerStatus } from './types/types.js';
+import { hexToBytes } from '../node_modules/@noble/curves/esm/abstract/utils.js';
+import { base32 } from '../node_modules/multiformats/dist/src/bases/base32.js';
+import * as index from '../_virtual/index.js';
+import { Ed25519PubKey } from './dc-key/ed25519.js';
+
+/**
+ * 区块链相关的方法
+ */
+const {
+  Buffer
+} = index;
+class ChainUtil {
+  constructor() {
+    Object.defineProperty(this, "dcchainapi", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    // 连接链节点
+    Object.defineProperty(this, "create", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async blockChainAddr => {
+        const chainProvider = new WsProvider(blockChainAddr);
+        this.dcchainapi = await ApiPromise.create({
+          provider: chainProvider,
+          throwOnConnect: true,
+          throwOnUnknown: true
+        });
+        if (!this.dcchainapi) {
+          console.error("dcchainapi init failed");
+          return false;
+        }
+        return true;
+      }
+    });
+    // 获取所有文件存储节点
+    Object.defineProperty(this, "getObjNodes", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async cid => {
+        const fileInfo = (await (this.dcchainapi?.query).dcNode.files(cid)) || null;
+        const fileInfoJSON = fileInfo?.toJSON();
+        if (!fileInfoJSON || typeof fileInfoJSON !== "object" || fileInfoJSON.peers.length == 0) {
+          return;
+        }
+        const peers = fileInfoJSON.peers || [];
+        return peers;
+      }
+    });
+    // 获取用户节点列表
+    Object.defineProperty(this, "getAccountPeers", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async account => {
+        try {
+          const hexAccount = "0x" + Buffer.from(account).toString("hex");
+          const userInfo = await this.getUserInfoWithAccount(hexAccount);
+          if (!userInfo || !isUser(userInfo)) {
+            return null;
+          }
+          const peers = userInfo.peers;
+          return peers;
+        } catch (error) {
+          console.error("getAccountPeers error:", error);
+          return null;
+        }
+      }
+    });
+    // 链上查询节点信息
+    // getDcNodeAddr = async (peerid: string) => {
+    //   const peerInfo = await (this.dcchainapi?.query as any).dcNode.peers(peerid);
+    //   const peerInfoJson = peerInfo?.toJSON();
+    //   if (
+    //     !peerInfoJson ||
+    //     typeof peerInfoJson !== "object" ||
+    //     (peerInfoJson as { ipAddress: string }).ipAddress == ""
+    //   ) {
+    //     console.log("no ip address found for peer: ", peerid);
+    //     return;
+    //   }
+    //   let nodeAddr = Buffer.from(
+    //     (peerInfoJson as { ipAddress: string }).ipAddress.slice(2),
+    //     "hex"
+    //   ).toString("utf8");
+    //   let addrParts = nodeAddr.split(",");
+    //   nodeAddr = addrParts[0];
+    //   //节点ws监听端口号在原来的tcp监听的基础上加10
+    //   let newNodeAddr = "";
+    //   const parts = nodeAddr.split("/");
+    //   for (let i = 0; i < parts.length; i++) {
+    //     if (parts[i] == "tcp" && i < parts.length - 1) {
+    //       const newPort = parseInt(parts[i + 1]) + 10;
+    //       newNodeAddr += parts[i] + "/" + newPort + "/";
+    //       i++;
+    //     } else if (parts[i] == "p2p") {
+    //       newNodeAddr += "ws/" + parts[i] + "/";
+    //     } else {
+    //       newNodeAddr += parts[i] + "/";
+    //     }
+    //   }
+    //   const addr = multiaddr(newNodeAddr);
+    //   console.log("newNodeAddr", newNodeAddr);
+    //   return addr;
+    // };
+    // 链上查询节点webrtc direct的地址信息,
+    // peerid: 节点的peerid
+    // 直接连接节点的地址
+    Object.defineProperty(this, "getDcNodeWebrtcDirectAddr", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async peerid => {
+        const peerInfo = await (this.dcchainapi?.query).dcNode.peers(peerid);
+        const peerInfoJson = peerInfo?.toJSON();
+        if (!peerInfoJson || typeof peerInfoJson !== "object" || peerInfoJson.ipAddress == "") {
+          console.error("no ip address found for peer: ", peerid);
+          return [null, PeerStatus.PeerStatusOffline];
+        }
+        let nodeAddr = Buffer.from(peerInfoJson.ipAddress.slice(2), "hex").toString("utf8");
+        let addrParts = nodeAddr.split(",");
+        if (addrParts.length < 2) {
+          return [null, PeerStatus.PeerStatusOffline];
+        }
+        const addr = multiaddr(addrParts[1]);
+        const peerStatus = peerInfoJson.status || PeerStatus.PeerStatusOffline;
+        return [addr, peerStatus];
+      }
+    });
+    // 链上查询节点列表
+    Object.defineProperty(this, "getDcNodeList", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async () => {
+        const peerList = await (this.dcchainapi?.query).dcNode.onlineNodesAddress();
+        const peerListJson = peerList?.toJSON();
+        console.log("peerListJson================================================", peerListJson);
+        if (!peerListJson || typeof peerListJson !== "object") {
+          console.error("no peer list found");
+          return [];
+        }
+        let peers = [];
+        if (Array.isArray(peerListJson)) {
+          for (let i = 0; i < peerListJson.length; i++) {
+            const peer = peerListJson[i];
+            if (typeof peer === "string") {
+              const peerJson = Buffer.from(peer.slice(2), "hex").toString("utf8");
+              peers = peers.concat(peerJson);
+            }
+          }
+        }
+        console.log("peers", peers);
+        return peers;
+      }
+    });
+    Object.defineProperty(this, "objectState", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async cid => {
+        if (!this.dcchainapi) {
+          return [null, new Error("dcchainapi is not initialized")];
+        }
+        const fileInfo = await this.dcchainapi.query.dcNode.files(cid);
+        if (!fileInfo || fileInfo.isEmpty) {
+          return [null, new Error(`File with CID ${cid} not found`)];
+        }
+        const data = fileInfo.toJSON();
+        if (!data) {
+          return [null, new Error(`File with CID ${cid} not found`)];
+        }
+        // 构造返回数据  
+        if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+          return [{
+            size: Number(data['fileSize'] || 0),
+            utype: Number(data['fileType'] || 0),
+            peers: new Set(Array.isArray(data['peers']) ? data['peers'].map(peer => {
+              try {
+                return hexToAscii(String(peer));
+              } catch (e) {
+                console.warn('Failed to convert peer ID format:', e);
+                return String(peer); // 如果转换失败，保留原格式
+              }
+            }) : []),
+            users: new Set(Array.isArray(data['users']) ? data['users'].map(String) : []),
+            mbusers: new Set(Array.isArray(data['users']) ? data['users'].map(user => {
+              try {
+                const userBytes = hexToBytes(user.slice(2));
+                const mbUser = base32.encode(userBytes);
+                return mbUser;
+              } catch (e) {
+                console.warn('Failed to convert peer ID format:', e);
+                return String(user); // 如果转换失败，保留原格式
+              }
+            }) : []),
+            logs: new Set(Array.isArray(data['dbLog']) ? data['dbLog'].map(log => {
+              try {
+                return hexToAscii(String(log));
+              } catch (e) {
+                console.warn('Failed to convert peer ID format:', e);
+                return String(log); // 如果转换失败，保留原格式
+              }
+            }) : [])
+          }, null];
+        }
+        return [null, new Error(`File with CID ${cid} not found`)];
+      }
+    });
+    Object.defineProperty(this, "ifEnoughUserSpace", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async (pubkeyRaw, needSize) => {
+        const hexAccount = "0x" + Buffer.from(pubkeyRaw).toString("hex");
+        // 获取用户存储空间
+        const userInfo = await this.getUserInfoWithAccount(hexAccount);
+        if (!userInfo) {
+          throw new Error("get user info error");
+        }
+        // 用户冻结
+        if (userInfo.commentFrozenStatus != 0 || userInfo.spamFrozenStatus != 0) {
+          return false;
+        }
+        // 过期高度判断
+        const blockHeight = (await this.getBlockHeight()) || 0;
+        if (userInfo.expireNumber > 0 && userInfo.expireNumber < blockHeight) {
+          return false;
+        }
+        // 用户存储空间判断
+        const needSizeNumber = needSize || 1024 * 1024; // 1M
+        if (userInfo.subscribeSpace - userInfo.usedSpace < needSizeNumber) {
+          return false;
+        }
+        return true;
+      }
+    });
+    Object.defineProperty(this, "refreshUserInfo", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async pubkeyRaw => {
+        const hexAccount = "0x" + Buffer.from(pubkeyRaw).toString("hex");
+        const userInfo = await this.getUserInfoWithAccount(hexAccount);
+        return userInfo;
+      }
+    });
+    // 获取应用信息
+    Object.defineProperty(this, "getAPPInfo", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async appId => {
+        if (!this.dcchainapi || !this.dcchainapi.isReady) {
+          throw new Error("dcchainapi is not initialized");
+        }
+        const appIdBytes = new TextEncoder().encode(appId);
+        const appIdHex = "0x" + Buffer.from(appIdBytes).toString("hex");
+        const appInfoStr = await (this.dcchainapi?.query).dcNode.appsInfo(appIdHex);
+        if (!appInfoStr || appInfoStr.isEmpty) {
+          throw new Error(`App info for ${appId} not found`);
+        }
+        const appJsonInfo = appInfoStr.toJSON();
+        if (!appJsonInfo || typeof appJsonInfo !== "object") {
+          throw new Error(`App info for ${appId} is not valid`);
+        }
+        //将 ownerAccount 转换为 Ed25519PubKey
+        const ownerBytes = hexToBytes(appJsonInfo?.ownerAccount.slice(2));
+        const owner = new Ed25519PubKey(ownerBytes);
+        const rewarder = appJsonInfo?.rewardedStash;
+        let domain = "";
+        if (appJsonInfo?.domain && appJsonInfo?.domain.length > 0) {
+          const domainBytes = hexToBytes(appJsonInfo?.domain.slice(2));
+          domain = new TextDecoder().decode(domainBytes).toString();
+        }
+        let fid = "";
+        if (appJsonInfo?.fid && appJsonInfo?.fid.length > 0) {
+          const fidBytes = hexToBytes(appJsonInfo?.fid.slice(2));
+          fid = new TextDecoder().decode(fidBytes).toString();
+        }
+        const appInfo = {
+          appId: appId,
+          domain: domain,
+          owner: owner.string(),
+          rewarder: rewarder,
+          fid: fid
+        };
+        return appInfo;
+      }
+    });
+  }
+  // 获取区块高度
+  async getBlockHeight() {
+    const lastBlock = await this.dcchainapi?.rpc.chain.getBlock();
+    const blockHeight = lastBlock?.block.header.number.toNumber();
+    return blockHeight || 0;
+  }
+  // 获取用户钱包信息
+  async getUserInfoWithAccount(account) {
+    const walletAccountStorage = await (this.dcchainapi?.query).dcNode.walletAccountStorage(account);
+    if (!walletAccountStorage) {
+      throw new Error("walletAccountStorage is null");
+    }
+    let userInfo = walletAccountStorage.toJSON();
+    if (userInfo === null) {
+      throw new Error("userInfo is null");
+    }
+    if (userInfo?.parentAccount !== account) {
+      const parentWalletAccountStorage = await (this.dcchainapi?.query).dcNode.walletAccountStorage(userInfo?.parentAccount);
+      if (!parentWalletAccountStorage) {
+        throw new Error("parentWalletAccountStorage is null");
+      }
+      const parentUserInfo = parentWalletAccountStorage?.toJSON();
+      if (!parentUserInfo || false) {
+        return userInfo;
+      }
+      userInfo.requestPeers = parentUserInfo.requestPeers;
+      if (userInfo.peers?.length == 0) {
+        //If the sub-account does not have account backup node information (this will happen if the sub-account is not bound to an nft account), the backup node information of the parent account will be obtained.
+        userInfo.peers = parentUserInfo.peers;
+      }
+      userInfo.subscribeSpace = parentUserInfo.subscribeSpace;
+      userInfo.usedSpace = parentUserInfo.usedSpace;
+      userInfo.expireNumber = parentUserInfo.expireNumber;
+      userInfo.purchaseNumber = parentUserInfo.purchaseNumber;
+      // 冻结不为0则更新
+      if (parentUserInfo.commentFrozenStatus != 0) {
+        userInfo.commentFrozenStatus = parentUserInfo.commentFrozenStatus;
+      }
+      if (parentUserInfo.spamFrozenStatus != 0) {
+        userInfo.spamFrozenStatus = parentUserInfo.spamFrozenStatus;
+      }
+    }
+    //peers 进行统一处理
+    for (let i = 0; i < userInfo.peers.length; i++) {
+      userInfo.peers[i] = hexToAscii(userInfo.peers[i]);
+    }
+    for (let i = 0; i < userInfo.requestPeers.length; i++) {
+      userInfo.requestPeers[i] = hexToAscii(userInfo.requestPeers[i]);
+    }
+    if (userInfo.dbConfig.length <= 2) {
+      userInfo.dbConfig = ""; // 如果 dbConfig 为空，则设置为 ""
+    } else {
+      userInfo.dbConfigRaw = hexToBytes(userInfo.dbConfig.slice(2));
+    }
+    if (userInfo.encNftAccount.length <= 2) {
+      userInfo.encNftAccount = "";
+    }
+    // 对 userInfo.peers 按与用户公钥的 XOR 距离进行排序
+    if (userInfo.peers && Array.isArray(userInfo.peers) && account) {
+      userInfo.peers.sort((peerA, peerB) => {
+        // 将 peer 字符串转换为 Uint8Array (如果需要)
+        const peerABytes = typeof peerA === 'string' ? new TextEncoder().encode(peerA) : peerA;
+        const peerBBytes = typeof peerB === 'string' ? new TextEncoder().encode(peerB) : peerB;
+        //account 是一个0x开头的16进制字符串转换为 Uint8Array
+        const accountBytes = hexToBytes(account.slice(2));
+        // 计算每个 peer 与公钥的 XOR 距离
+        const distance1 = this.calculateDistance(peerABytes, accountBytes);
+        const distance2 = this.calculateDistance(peerBBytes, accountBytes);
+        if (distance1 < distance2) return -1;
+        if (distance1 > distance2) return 1;
+        return 0;
+      });
+    }
+    return userInfo;
+  }
+  // 获取用户钱包信息
+  async getUserInfoWithNftHex(nftHexAccount) {
+    const walletAccount = await (this.dcchainapi?.query).dcNode.nftToWalletAccount(nftHexAccount);
+    if (!walletAccount || !walletAccount.toString()) {
+      throw new Error("walletAccount is null");
+    }
+    const userInfo = await this.getUserInfoWithAccount(walletAccount.toString());
+    return userInfo;
+  }
+  /**
+  * 计算两个字节数组之间的XOR距离
+  * @param key1 第一个字节数组
+  * @param key2 第二个字节数组
+  * @returns 两个键之间的XOR距离，以BigInt表示
+  */
+  calculateDistance(key1, key2) {
+    // 使用两个字节数组的最小长度
+    const minLen = Math.min(key1.length, key2.length);
+    // 创建结果数组存储XOR结果
+    const result = new Uint8Array(minLen);
+    // 按字节计算XOR距离
+    for (let i = 0; i < minLen; i++) {
+      result[i] = key1[i] ^ key2[i];
+    }
+    // 将结果转换为BigInt用于比较
+    // 首先转换为十六进制字符串以处理大数值
+    let hexString = '0x';
+    for (let i = 0; i < result.length; i++) {
+      hexString += result[i].toString(16).padStart(2, '0');
+    }
+    // 如果结果为空（全零），返回0n
+    if (hexString === '0x') {
+      return BigInt(0);
+    }
+    return BigInt(hexString);
+  }
+  // 获取用户钱包信息
+  async getUserInfoWithNft(nftAccount) {
+    console.log("=========nftAccount", nftAccount);
+    const accountBytes = new TextEncoder().encode(nftAccount);
+    const accountHash = await sha256(accountBytes);
+    const nftHexAccount = "0x" + Buffer.from(accountHash).toString("hex");
+    const userInfo = await this.getUserInfoWithNftHex(nftHexAccount);
+    return userInfo;
+  }
+  async getUserWalletAccount(nftAccount) {
+    const accountBytes = new TextEncoder().encode(nftAccount);
+    const accountHash = await sha256(accountBytes);
+    const nftHexAccount = "0x" + Buffer.from(accountHash).toString("hex");
+    const walletAccount = await (this.dcchainapi?.query).dcNode.nftToWalletAccount(nftHexAccount);
+    if (!walletAccount || !walletAccount.toString()) {
+      throw new Error("walletAccount is null");
+    }
+    return walletAccount.toString();
+  }
+}
+
+export { ChainUtil };

package/dist/esm/common/commonclient.js

@@ -0,0 +1,123 @@
+import { keys } from '@libp2p/crypto';
+import { Ed25519PubKey } from './dc-key/ed25519.js';
+import { extractPeerIdFromMultiaddr, generateSymKeyForPrikey, extractPublicKeyFromPeerId } from './dc-key/keyManager.js';
+import { sha256, getRandomBytes, concatenateUint8Arrays } from '../util/utils.js';
+import { Encryption } from '../util/curve25519Encryption.js';
+import { decryptContent } from '../util/dccrypt.js';
+import { toString } from '../node_modules/uint8arrays/dist/src/to-string.js';
+import { Libp2pGrpcClient } from 'grpc-libp2p-client';
+import { dcnet } from '../proto/dcnet_proto.js';
+
+class CommonClient {
+  constructor(dcClient) {
+    Object.defineProperty(this, "client", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.client = dcClient;
+  }
+  // 登陆
+  async accountLogin(nftAccount, password, safecode) {
+    //登录
+    const prikey = await this._accountDoLogin(nftAccount, password, safecode, this.client.peerAddr);
+    let mnemonic = "";
+    if (prikey.startsWith("mnemonic:")) {
+      mnemonic = prikey.slice(9);
+      return mnemonic;
+    }
+    return '';
+  }
+  async _accountDoLogin(account, password, seccode, peerAddr) {
+    if (this.client.p2pNode == null || this.client.p2pNode.peerId == null) {
+      throw new Error("p2pNode is null or node privateKey is null");
+    }
+    //生成临时ed25519公私钥对
+    const keyPair = await keys.generateKeyPair("Ed25519");
+    // 获取私钥
+    const privateKeyRaw = keyPair.raw;
+    // 获取公钥
+    const publicKey = keyPair.publicKey;
+    const tempEdPubkey = Ed25519PubKey.formEd25519PublicKey(publicKey);
+    //multiaddr 中提取peerid
+    const peerId = await extractPeerIdFromMultiaddr(peerAddr);
+    console.log("peerId:", peerId.toString());
+    // 获取当前节点的peerID,并且获取节点的公钥
+    this.client.p2pNode.peerId.publicKey;
+    const req = await generateAccountLoginRequestWithPeerId(peerId, account, password, seccode, tempEdPubkey);
+    const prikeyencrypt2 = await this._accountloginApi(req.accounthashencrypt, req.pubkeyencrypt, req.loginkeyrandencrypt, peerAddr);
+    //从返回的数据中解析出私钥
+    //Decrypt with private key
+    const prikeyEncrypt = await Encryption.decrypt(privateKeyRaw, prikeyencrypt2);
+    const aeskey = await generateSymKeyForPrikey(account, password);
+    //Aes gcm解密
+    const prikey = await decryptContent(prikeyEncrypt, aeskey.raw);
+    return toString(prikey);
+  }
+  async _accountloginApi(accounthashencrypt, pubkeyencrypt, loginkeyrandencrypt, peerAddr) {
+    try {
+      const grpcClient = new Libp2pGrpcClient(this.client.p2pNode, peerAddr || this.client.peerAddr, this.client.token, this.client.protocol);
+      const message = new dcnet.pb.AccountLoginRequest({});
+      message.accounthashencrypt = accounthashencrypt;
+      message.pubkeyencrypt = pubkeyencrypt;
+      message.loginkeyrandencrypt = loginkeyrandencrypt;
+      const messageBytes = dcnet.pb.AccountLoginRequest.encode(message).finish();
+      const responseData = await grpcClient.unaryCall("/dcnet.pb.Service/AccountLogin", messageBytes, 30000);
+      const decoded = dcnet.pb.AccountLoginReply.decode(responseData);
+      const prikeyencrypt2 = decoded.prikeyencrypt2;
+      return prikeyencrypt2;
+    } catch (err) {
+      console.error("AccountLogin error:", err);
+      throw err;
+    }
+  }
+}
+/**
+ * 生成账户登录请求
+ * @param peerId - 节点ID
+ * @param account - 账户名
+ * @param password - 密码
+ * @param seccode - 安全码
+ * @param pk - 返回数据加密用的公钥
+ * @returns 登录请求对象
+ */
+async function generateAccountLoginRequestWithPeerId(peerId, account, password, seccode, pk) {
+  try {
+    // 获取节点公钥
+    const peerPubkey = await extractPublicKeyFromPeerId(peerId);
+    const serverPubkey = peerPubkey; // 假设已经做了适当的转换
+    // 计算账户哈希
+    const accountBytes = new TextEncoder().encode(account);
+    const accountHash = await sha256(accountBytes);
+    // 使用节点公钥加密账户哈希
+    const accountHashCrypt = await Encryption.encrypt(serverPubkey.raw, accountHash);
+    // 获取并加密公钥
+    const pkBytes = pk.raw;
+    const pubkeyEncrypt = await Encryption.encrypt(serverPubkey.raw, pkBytes);
+    // 生成随机密钥
+    const randKey = getRandomBytes(32);
+    // 计算密码哈希
+    const passwordBytes = new TextEncoder().encode(password);
+    const passwordSlice = passwordBytes.slice(0, 2);
+    const passwordHash = await sha256(passwordSlice);
+    const passwordHashLast2 = passwordHash.slice(-2);
+    // 计算登录密钥
+    const seccodeBytes = new TextEncoder().encode(seccode);
+    const loginKeySeed = concatenateUint8Arrays(accountHash, passwordHashLast2, seccodeBytes);
+    const loginkey = await sha256(loginKeySeed);
+    // 加密登录密钥和随机密钥
+    const loginkeyRand = concatenateUint8Arrays(loginkey, randKey);
+    const loginkeyRandEncrypt = await Encryption.encrypt(serverPubkey.raw, loginkeyRand);
+    // 返回登录请求对象
+    return {
+      accounthashencrypt: accountHashCrypt,
+      pubkeyencrypt: pubkeyEncrypt,
+      loginkeyrandencrypt: loginkeyRandEncrypt
+    };
+  } catch (error) {
+    throw new Error(`Failed to generate login request: ${error.message}`);
+  }
+}
+
+export { CommonClient };

package/dist/esm/common/constants.js

@@ -0,0 +1,54 @@
+var Type;
+(function (Type) {
+  Type[Type["Filetype"] = 1] = "Filetype";
+  Type[Type["Threaddbtype"] = 2] = "Threaddbtype";
+})(Type || (Type = {}));
+// cid是否需要连接节点
+const cidNeedConnect = {
+  NEED: 0,
+  NOT_NEED: 1
+};
+// openFlag 开放标志 
+var OpenFlag;
+(function (OpenFlag) {
+  OpenFlag[OpenFlag["PUBLIC"] = 0] = "PUBLIC";
+  OpenFlag[OpenFlag["PRIVATE"] = 1] = "PRIVATE";
+  OpenFlag[OpenFlag["AUTH"] = 2] = "AUTH";
+  OpenFlag[OpenFlag["AUTH_WRITE"] = 3] = "AUTH_WRITE";
+  OpenFlag[OpenFlag["REPORTED"] = 4] = "REPORTED";
+})(OpenFlag || (OpenFlag = {}));
+var AIProxyUserPermission;
+(function (AIProxyUserPermission) {
+  AIProxyUserPermission[AIProxyUserPermission["QUERY"] = 8] = "QUERY";
+  AIProxyUserPermission[AIProxyUserPermission["ADMIN"] = 4] = "ADMIN";
+})(AIProxyUserPermission || (AIProxyUserPermission = {}));
+/**
+ * 主题的操作权限
+ */
+var ThemePermission;
+(function (ThemePermission) {
+  /** 无权限 */
+  ThemePermission[ThemePermission["NONE"] = 0] = "NONE";
+  /** 申请权限 */
+  ThemePermission[ThemePermission["APPLY"] = 1] = "APPLY";
+  /** 读权限 */
+  ThemePermission[ThemePermission["READ"] = 2] = "READ";
+  /** 写权限 */
+  ThemePermission[ThemePermission["WRITE"] = 3] = "WRITE";
+  /** 管理员权限 */
+  ThemePermission[ThemePermission["ADMIN"] = 4] = "ADMIN";
+  /**
+   * 只写权限
+   * 不允许用户修改remark或者物联网设备上报数据使用
+   * 权限后面跟随分组列表,以逗号分隔
+   */
+  ThemePermission[ThemePermission["ONLY_WRITE"] = 5] = "ONLY_WRITE";
+  /** 物联网管理人员相关权限,具体权限后续可扩展 */
+  ThemePermission[ThemePermission["DEVICE"] = 6] = "DEVICE";
+  /** 不存在 */
+  ThemePermission[ThemePermission["NOT_EXIST"] = 7] = "NOT_EXIST";
+  /** 查询权限,系统可以查询数据,用户只能查询自己的授权数据 */
+  ThemePermission[ThemePermission["QUERY"] = 8] = "QUERY";
+})(ThemePermission || (ThemePermission = {}));
+
+export { AIProxyUserPermission, OpenFlag, ThemePermission, Type, cidNeedConnect };