@hashgraphonline/standards-sdk 0.0.185 → 0.0.187

package/dist/es/standards-sdk.es81.js

@@ -1,309 +1,334 @@
-const protoFieldToTypeRegistry = {
-  tokenCreation: { type: "TOKENCREATE", humanReadableType: "Token Creation" },
-  tokenAirdrop: { type: "TOKENAIRDROP", humanReadableType: "Token Airdrop" },
-  tokenMint: { type: "TOKENMINT", humanReadableType: "Token Mint" },
-  tokenBurn: { type: "TOKENBURN", humanReadableType: "Token Burn" },
-  tokenUpdate: { type: "TOKENUPDATE", humanReadableType: "Token Update" },
-  tokenDeletion: { type: "TOKENDELETE", humanReadableType: "Token Deletion" },
-  tokenAssociate: {
-    type: "TOKENASSOCIATE",
-    humanReadableType: "Token Association"
-  },
-  tokenDissociate: {
-    type: "TOKENDISSOCIATE",
-    humanReadableType: "Token Dissociation"
-  },
-  tokenFreeze: { type: "TOKENFREEZE", humanReadableType: "Token Freeze" },
-  tokenUnfreeze: { type: "TOKENUNFREEZE", humanReadableType: "Token Unfreeze" },
-  tokenGrantKyc: {
-    type: "TOKENGRANTKYC",
-    humanReadableType: "Token Grant KYC"
-  },
-  tokenRevokeKyc: {
-    type: "TOKENREVOKEKYC",
-    humanReadableType: "Token Revoke KYC"
-  },
-  tokenPause: { type: "TOKENPAUSE", humanReadableType: "Token Pause" },
-  tokenUnpause: { type: "TOKENUNPAUSE", humanReadableType: "Token Unpause" },
-  tokenWipe: { type: "TOKENWIPE", humanReadableType: "Token Wipe" },
-  tokenFeeScheduleUpdate: {
-    type: "TOKENFEESCHEDULEUPDATE",
-    humanReadableType: "Token Fee Schedule Update"
-  },
-  tokenCancelAirdrop: {
-    type: "TOKENCANCELAIRDROP",
-    humanReadableType: "Cancel Token Airdrop"
-  },
-  tokenClaimAirdrop: {
-    type: "TOKENCLAIMAIRDROP",
-    humanReadableType: "Claim Token Airdrop"
-  },
-  tokenReject: { type: "TOKENREJECT", humanReadableType: "Token Reject" },
-  tokenUpdateNfts: {
-    type: "TOKENUPDATENFTS",
-    humanReadableType: "Update NFT Metadata"
-  },
-  cryptoTransfer: {
-    type: "CRYPTOTRANSFER",
-    humanReadableType: "Crypto Transfer"
-  },
-  cryptoCreateAccount: {
-    type: "ACCOUNTCREATE",
-    humanReadableType: "Account Creation"
-  },
-  cryptoUpdateAccount: {
-    type: "ACCOUNTUPDATE",
-    humanReadableType: "Account Update"
-  },
-  cryptoDelete: {
-    type: "ACCOUNTDELETE",
-    humanReadableType: "Account Deletion"
-  },
-  cryptoApproveAllowance: {
-    type: "APPROVEALLOWANCE",
-    humanReadableType: "Approve Allowance"
-  },
-  cryptoDeleteAllowance: {
-    type: "DELETEALLOWANCE",
-    humanReadableType: "Delete Allowance"
-  },
-  cryptoAddLiveHash: {
-    type: "CRYPTOADDLIVEHASH",
-    humanReadableType: "Add Live Hash"
-  },
-  cryptoDeleteLiveHash: {
-    type: "CRYPTODELETELIVEHASH",
-    humanReadableType: "Delete Live Hash"
-  },
-  consensusCreateTopic: {
-    type: "TOPICCREATE",
-    humanReadableType: "Topic Creation"
-  },
-  consensusSubmitMessage: {
-    type: "CONSENSUSSUBMITMESSAGE",
-    humanReadableType: "Submit Message"
-  },
-  consensusUpdateTopic: {
-    type: "TOPICUPDATE",
-    humanReadableType: "Topic Update"
-  },
-  consensusDeleteTopic: {
-    type: "TOPICDELETE",
-    humanReadableType: "Topic Deletion"
-  },
-  uncheckedSubmit: {
-    type: "UNCHECKEDSUBMIT",
-    humanReadableType: "Unchecked Submit"
-  },
-  contractCall: { type: "CONTRACTCALL", humanReadableType: "Contract Call" },
-  contractCreateInstance: {
-    type: "CONTRACTCREATE",
-    humanReadableType: "Contract Creation"
-  },
-  contractUpdateInstance: {
-    type: "CONTRACTUPDATE",
-    humanReadableType: "Contract Update"
-  },
-  contractDeleteInstance: {
-    type: "CONTRACTDELETE",
-    humanReadableType: "Contract Deletion"
-  },
-  ethereumTransaction: {
-    type: "ETHEREUMTRANSACTION",
-    humanReadableType: "Ethereum Transaction"
-  },
-  fileCreate: { type: "FILECREATE", humanReadableType: "File Creation" },
-  fileUpdate: { type: "FILEUPDATE", humanReadableType: "File Update" },
-  fileDelete: { type: "FILEDELETE", humanReadableType: "File Deletion" },
-  fileAppend: { type: "FILEAPPEND", humanReadableType: "File Append" },
-  scheduleCreate: {
-    type: "SCHEDULECREATE",
-    humanReadableType: "Schedule Creation"
-  },
-  scheduleSign: { type: "SCHEDULESIGN", humanReadableType: "Schedule Sign" },
-  scheduleDelete: {
-    type: "SCHEDULEDELETE",
-    humanReadableType: "Schedule Deletion"
-  },
-  freeze: { type: "FREEZE", humanReadableType: "Network Freeze" },
-  systemDelete: { type: "SYSTEMDELETE", humanReadableType: "System Delete" },
-  systemUndelete: {
-    type: "SYSTEMUNDELETE",
-    humanReadableType: "System Undelete"
-  },
-  nodeCreate: { type: "NODECREATE", humanReadableType: "Node Creation" },
-  nodeUpdate: { type: "NODEUPDATE", humanReadableType: "Node Update" },
-  nodeDelete: { type: "NODEDELETE", humanReadableType: "Node Deletion" },
-  nodeStakeUpdate: {
-    type: "NODESTAKEUPDATE",
-    humanReadableType: "Node Stake Update"
-  },
-  utilPrng: { type: "PRNG", humanReadableType: "Pseudo Random Number" },
-  atomicBatch: { type: "ATOMICBATCH", humanReadableType: "Atomic Batch" },
-  stateSignatureTransaction: {
-    type: "STATESIGNATURETRANSACTION",
-    humanReadableType: "State Signature"
-  },
-  historyProofSignature: {
-    type: "HISTORYPROOFSIGNATURE",
-    humanReadableType: "History Proof Signature"
-  },
-  historyProofKeyPublication: {
-    type: "HISTORYPROOFKEYPUBLICATION",
-    humanReadableType: "History Proof Key Publication"
-  },
-  historyProofVote: {
-    type: "HISTORYPROOFVOTE",
-    humanReadableType: "History Proof Vote"
-  },
-  hintsPreprocessingVote: {
-    type: "HINTSPREPROCESSINGVOTE",
-    humanReadableType: "Hints Preprocessing Vote"
-  },
-  hintsKeyPublication: {
-    type: "HINTSKEYPUBLICATION",
-    humanReadableType: "Hints Key Publication"
-  },
-  hintsPartialSignature: {
-    type: "HINTSPARTIALSIGNATURE",
-    humanReadableType: "Hints Partial Signature"
-  },
-  crsPublication: {
-    type: "CRSPUBLICATION",
-    humanReadableType: "CRS Publication"
-  },
-  transactionID: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" },
-  nodeAccountID: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" },
-  transactionFee: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" },
-  transactionValidDuration: {
-    type: "UNKNOWN",
-    humanReadableType: "Unknown Transaction"
-  },
-  generateRecord: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" },
-  memo: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" },
-  batchKey: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" },
-  maxCustomFees: { type: "UNKNOWN", humanReadableType: "Unknown Transaction" }
-};
-const humanReadableTypeRegistry = {
-  cryptoTransfer: "HBAR Transfer",
-  CRYPTOTRANSFER: "HBAR Transfer",
-  cryptoCreateAccount: "Create Account",
-  ACCOUNTCREATE: "Create Account",
-  cryptoUpdateAccount: "Update Account",
-  ACCOUNTUPDATE: "Update Account",
-  cryptoDeleteAccount: "Delete Account",
-  cryptoDelete: "Delete Account",
-  ACCOUNTDELETE: "Delete Account",
-  cryptoApproveAllowance: "Approve Allowance",
-  APPROVEALLOWANCE: "Approve Allowance",
-  cryptoDeleteAllowance: "Delete Allowance",
-  DELETEALLOWANCE: "Delete Allowance",
-  CRYPTOADDLIVEHASH: "Add Live Hash",
-  CRYPTODELETELIVEHASH: "Delete Live Hash",
-  consensusCreateTopic: "Create Topic",
-  TOPICCREATE: "Create Topic",
-  consensusUpdateTopic: "Update Topic",
-  TOPICUPDATE: "Update Topic",
-  consensusSubmitMessage: "Submit Message",
-  CONSENSUSSUBMITMESSAGE: "Submit Message",
-  consensusDeleteTopic: "Delete Topic",
-  TOPICDELETE: "Delete Topic",
-  UNCHECKEDSUBMIT: "Unchecked Submit",
-  fileCreate: "Create File",
-  FILECREATE: "Create File",
-  fileAppend: "Append File",
-  FILEAPPEND: "Append File",
-  fileUpdate: "Update File",
-  FILEUPDATE: "Update File",
-  fileDelete: "Delete File",
-  FILEDELETE: "Delete File",
-  contractCall: "Contract Call",
-  CONTRACTCALL: "Contract Call",
-  contractCreate: "Create Contract",
-  CONTRACTCREATE: "Create Contract",
-  contractUpdate: "Update Contract",
-  CONTRACTUPDATE: "Update Contract",
-  contractDelete: "Delete Contract",
-  CONTRACTDELETE: "Delete Contract",
-  ethereumTransaction: "Ethereum Transaction",
-  ETHEREUMTRANSACTION: "Ethereum Transaction",
-  tokenCreate: "Create Token",
-  TOKENCREATE: "Create Token",
-  tokenUpdate: "Update Token",
-  TOKENUPDATE: "Update Token",
-  tokenDelete: "Delete Token",
-  TOKENDELETE: "Delete Token",
-  tokenAssociate: "Associate Token",
-  TOKENASSOCIATE: "Associate Token",
-  tokenDissociate: "Dissociate Token",
-  TOKENDISSOCIATE: "Dissociate Token",
-  tokenMint: "Mint Token",
-  TOKENMINT: "Mint Token",
-  tokenBurn: "Burn Token",
-  TOKENBURN: "Burn Token",
-  tokenFeeScheduleUpdate: "Update Token Fee Schedule",
-  TOKENFEESCHEDULEUPDATE: "Update Token Fee Schedule",
-  tokenFreeze: "Freeze Token",
-  TOKENFREEZE: "Freeze Token",
-  tokenUnfreeze: "Unfreeze Token",
-  TOKENUNFREEZE: "Unfreeze Token",
-  tokenGrantKyc: "Grant KYC",
-  TOKENGRANTKYC: "Grant KYC",
-  tokenRevokeKyc: "Revoke KYC",
-  TOKENREVOKEKYC: "Revoke KYC",
-  tokenPause: "Pause Token",
-  TOKENPAUSE: "Pause Token",
-  tokenUnpause: "Unpause Token",
-  TOKENUNPAUSE: "Unpause Token",
-  tokenWipe: "Wipe Token",
-  TOKENWIPE: "Wipe Token",
-  tokenAirdrop: "Token Airdrop",
-  TOKENAIRDROP: "Token Airdrop",
-  TOKENCANCELAIRDROP: "Cancel Token Airdrop",
-  TOKENCLAIMAIRDROP: "Claim Token Airdrop",
-  TOKENREJECT: "Token Reject",
-  TOKENUPDATENFTS: "Update NFT Metadata",
-  scheduleCreate: "Create Schedule",
-  SCHEDULECREATE: "Create Schedule",
-  scheduleSign: "Sign Schedule",
-  SCHEDULESIGN: "Sign Schedule",
-  SCHEDULEDELETE: "Delete Schedule",
-  FREEZE: "Network Freeze",
-  SYSTEMDELETE: "System Delete",
-  SYSTEMUNDELETE: "System Undelete",
-  NODECREATE: "Create Node",
-  NODEUPDATE: "Update Node",
-  NODEDELETE: "Delete Node",
-  NODESTAKEUPDATE: "Update Node Stake",
-  utilPrng: "Generate Random Number",
-  PRNG: "Generate Random Number",
-  ATOMICBATCH: "Atomic Batch",
-  STATESIGNATURETRANSACTION: "State Signature",
-  HISTORYPROOFSIGNATURE: "History Proof Signature",
-  HISTORYPROOFKEYPUBLICATION: "History Proof Key Publication",
-  HISTORYPROOFVOTE: "History Proof Vote",
-  HINTSPREPROCESSINGVOTE: "Hints Preprocessing Vote",
-  HINTSKEYPUBLICATION: "Hints Key Publication",
-  HINTSPARTIALSIGNATURE: "Hints Partial Signature",
-  CRSPUBLICATION: "CRS Publication",
-  unknown: "Unknown Transaction",
-  UNKNOWN: "Unknown Transaction"
-};
-function getTransactionTypeFromBody(txBody) {
-  for (const [field, typeInfo] of Object.entries(protoFieldToTypeRegistry)) {
-    if (txBody[field]) {
-      return typeInfo;
+import { proto } from "@hashgraph/proto";
+import { Long, FileId, ContractId } from "@hashgraph/sdk";
+import { hasTransactionType } from "./standards-sdk.es83.js";
+class UtilParser {
+  /**
+   * Parse Utility/System Service transaction using unified dual-branch approach
+   * This handles both regular transactions and signed transaction variants
+   */
+  static parseUtilTransaction(transaction, originalBytes) {
+    try {
+      if (originalBytes || transaction.toBytes) {
+        try {
+          const bytesToParse = originalBytes || transaction.toBytes();
+          const decoded = proto.TransactionList.decode(bytesToParse);
+          if (decoded.transactionList && decoded.transactionList.length > 0) {
+            const tx = decoded.transactionList[0];
+            let txBody = null;
+            if (tx.bodyBytes && tx.bodyBytes.length > 0) {
+              txBody = proto.TransactionBody.decode(tx.bodyBytes);
+            } else if (tx.signedTransactionBytes && tx.signedTransactionBytes.length > 0) {
+              const signedTx = proto.SignedTransaction.decode(
+                tx.signedTransactionBytes
+              );
+              if (signedTx.bodyBytes) {
+                txBody = proto.TransactionBody.decode(signedTx.bodyBytes);
+              }
+            }
+            if (txBody) {
+              const protoResult = this.parseFromProtobufTxBody(txBody);
+              if (protoResult.type && protoResult.type !== "UNKNOWN") {
+                return protoResult;
+              }
+            }
+          }
+        } catch (protoError) {
+        }
+      }
+      return this.parseFromTransactionInternals(transaction);
+    } catch (error) {
+      return {
+        type: "UNKNOWN",
+        humanReadableType: "Unknown Utility Transaction"
+      };
     }
   }
-  return { type: "UNKNOWN", humanReadableType: "Unknown Transaction" };
-}
-function getHumanReadableTransactionType(type) {
-  return humanReadableTypeRegistry[type] || "Unknown Transaction";
+  /**
+   * Parse utility transaction from protobuf TransactionBody
+   * Handles all utility operations from decoded protobuf data
+   */
+  static parseFromProtobufTxBody(txBody) {
+    if (txBody.utilPrng) {
+      const utilPrng = this.parseUtilPrng(txBody.utilPrng);
+      if (utilPrng) {
+        return {
+          type: "PRNG",
+          humanReadableType: "Pseudo Random Number",
+          utilPrng
+        };
+      }
+    }
+    if (txBody.freeze) {
+      const networkFreeze = this.parseNetworkFreezeFromProto(txBody.freeze);
+      if (networkFreeze) {
+        return {
+          type: "FREEZE",
+          humanReadableType: "Network Freeze",
+          freeze: networkFreeze
+        };
+      }
+    }
+    if (txBody.systemDelete) {
+      const systemDelete = this.parseSystemDeleteFromProto(txBody.systemDelete);
+      if (systemDelete) {
+        return {
+          type: "SYSTEMDELETE",
+          humanReadableType: "System Delete",
+          systemDelete
+        };
+      }
+    }
+    if (txBody.systemUndelete) {
+      const systemUndelete = this.parseSystemUndeleteFromProto(
+        txBody.systemUndelete
+      );
+      if (systemUndelete) {
+        return {
+          type: "SYSTEMUNDELETE",
+          humanReadableType: "System Undelete",
+          systemUndelete
+        };
+      }
+    }
+    if (txBody.nodeCreate) {
+      const nodeCreate = this.parseNodeCreateFromProto(txBody.nodeCreate);
+      if (nodeCreate) {
+        return {
+          type: "NODECREATE",
+          humanReadableType: "Node Create",
+          nodeCreate
+        };
+      }
+    }
+    if (txBody.nodeUpdate) {
+      const nodeUpdate = this.parseNodeUpdateFromProto(txBody.nodeUpdate);
+      if (nodeUpdate) {
+        return {
+          type: "NODEUPDATE",
+          humanReadableType: "Node Update",
+          nodeUpdate
+        };
+      }
+    }
+    if (txBody.nodeDelete) {
+      const nodeDelete = this.parseNodeDeleteFromProto(txBody.nodeDelete);
+      if (nodeDelete) {
+        return {
+          type: "NODEDELETE",
+          humanReadableType: "Node Delete",
+          nodeDelete
+        };
+      }
+    }
+    return {};
+  }
+  /**
+   * Extract utility data from Transaction internal fields
+   * This handles cases where data is stored in Transaction object internals
+   */
+  static parseFromTransactionInternals(transaction) {
+    try {
+      const tx = transaction;
+      if (hasTransactionType(transaction, "utilPrng")) {
+        const utilPrng = {};
+        if (tx._range && tx._range !== 0) {
+          utilPrng.range = tx._range;
+        }
+        return {
+          type: "PRNG",
+          humanReadableType: "Pseudo Random Number",
+          utilPrng
+        };
+      }
+      if (hasTransactionType(transaction, "freeze")) {
+        const networkFreeze = {};
+        if (tx._startTime) {
+          networkFreeze.startTime = tx._startTime.toString();
+        }
+        if (tx._endTime) {
+          networkFreeze.endTime = tx._endTime.toString();
+        }
+        if (tx._updateFile) {
+          networkFreeze.updateFile = tx._updateFile.toString();
+        }
+        if (tx._fileHash) {
+          networkFreeze.fileHash = Buffer.from(tx._fileHash).toString("hex");
+        }
+        if (tx._freezeType) {
+          networkFreeze.freezeType = tx._freezeType;
+        }
+        return {
+          type: "FREEZE",
+          humanReadableType: "Network Freeze",
+          freeze: networkFreeze
+        };
+      }
+      if (hasTransactionType(transaction, "systemDelete")) {
+        const systemDelete = {};
+        if (tx._fileId) {
+          systemDelete.fileId = tx._fileId.toString();
+        } else if (tx._contractId) {
+          systemDelete.contractId = tx._contractId.toString();
+        }
+        if (tx._expirationTime) {
+          systemDelete.expirationTime = tx._expirationTime.toString();
+        }
+        return {
+          type: "SYSTEMDELETE",
+          humanReadableType: "System Delete",
+          systemDelete
+        };
+      }
+      if (hasTransactionType(transaction, "systemUndelete")) {
+        const systemUndelete = {};
+        if (tx._fileId) {
+          systemUndelete.fileId = tx._fileId.toString();
+        } else if (tx._contractId) {
+          systemUndelete.contractId = tx._contractId.toString();
+        }
+        return {
+          type: "SYSTEMUNDELETE",
+          humanReadableType: "System Undelete",
+          systemUndelete
+        };
+      }
+      return {};
+    } catch (error) {
+      return {};
+    }
+  }
+  /**
+   * Parse Network Freeze from protobuf data
+   */
+  static parseNetworkFreezeFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.startTime?.seconds) {
+      data.startTime = `${Long.fromValue(
+        body.startTime.seconds
+      ).toString()}.${body.startTime.nanos ?? 0}`;
+    }
+    if (body.updateFile) {
+      data.updateFile = new FileId(
+        body.updateFile.shardNum ?? 0,
+        body.updateFile.realmNum ?? 0,
+        body.updateFile.fileNum ?? 0
+      ).toString();
+    }
+    if (body.fileHash && body.fileHash.length > 0) {
+      data.fileHash = Buffer.from(body.fileHash).toString("hex");
+    }
+    if (body.freezeType !== void 0) {
+      const freezeTypes = [
+        "FREEZE_ONLY",
+        "PREPARE_UPGRADE",
+        "FREEZE_UPGRADE",
+        "FREEZE_ABORT"
+      ];
+      data.freezeType = freezeTypes[body.freezeType] || "FREEZE_ONLY";
+    }
+    return data;
+  }
+  /**
+   * Parse System Delete from protobuf data
+   */
+  static parseSystemDeleteFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.fileID) {
+      data.fileId = new FileId(
+        body.fileID.shardNum ?? 0,
+        body.fileID.realmNum ?? 0,
+        body.fileID.fileNum ?? 0
+      ).toString();
+    } else if (body.contractID) {
+      data.contractId = new ContractId(
+        body.contractID.shardNum ?? 0,
+        body.contractID.realmNum ?? 0,
+        body.contractID.contractNum ?? 0
+      ).toString();
+    }
+    if (body.expirationTime?.seconds) {
+      data.expirationTime = Long.fromValue(
+        body.expirationTime.seconds
+      ).toString();
+    }
+    return data;
+  }
+  /**
+   * Parse System Undelete from protobuf data
+   */
+  static parseSystemUndeleteFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.fileID) {
+      data.fileId = new FileId(
+        body.fileID.shardNum ?? 0,
+        body.fileID.realmNum ?? 0,
+        body.fileID.fileNum ?? 0
+      ).toString();
+    } else if (body.contractID) {
+      data.contractId = new ContractId(
+        body.contractID.shardNum ?? 0,
+        body.contractID.realmNum ?? 0,
+        body.contractID.contractNum ?? 0
+      ).toString();
+    }
+    return data;
+  }
+  /**
+   * Parse Node Create from protobuf data
+   */
+  static parseNodeCreateFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.nodeId !== void 0) {
+      data.nodeId = Long.fromValue(body.nodeId).toNumber();
+    }
+    return data;
+  }
+  /**
+   * Parse Node Update from protobuf data
+   */
+  static parseNodeUpdateFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.nodeId !== void 0) {
+      data.nodeId = Long.fromValue(body.nodeId).toNumber();
+    }
+    return data;
+  }
+  /**
+   * Parse Node Delete from protobuf data
+   */
+  static parseNodeDeleteFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.nodeId !== void 0) {
+      data.nodeId = Long.fromValue(body.nodeId).toNumber();
+    }
+    return data;
+  }
+  static parseUtilPrng(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.range && body.range !== 0) {
+      data.range = body.range;
+    }
+    return data;
+  }
+  static parseFreeze(body) {
+    return this.parseNetworkFreezeFromProto(body);
+  }
+  /**
+   * Parse Utility/System Service transaction from Transaction object
+   * This is the unified entry point that delegates to the comprehensive parsing logic
+   */
+  static parseFromTransactionObject(transaction) {
+    return this.parseUtilTransaction(transaction);
+  }
 }
 export {
-  getHumanReadableTransactionType,
-  getTransactionTypeFromBody,
-  humanReadableTypeRegistry,
-  protoFieldToTypeRegistry
+  UtilParser
 };
 //# sourceMappingURL=standards-sdk.es81.js.map