@hashgraphonline/standards-sdk 0.1.175 → 0.1.176

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

@@ -1,334 +1,715 @@
-import { proto } from "@hashgraph/proto";
-import { Long, FileId, ContractId } from "@hashgraph/sdk";
-import { hasTransactionType } from "./standards-sdk.es168.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"
-      };
-    }
+import { skillRegistryConfigResponseSchema, skillStatusResponseSchema, skillRegistryListResponseSchema, skillSecurityBreakdownResponseSchema, skillCatalogResponseSchema, skillRegistryVersionsResponseSchema, skillRegistryMineResponseSchema, skillRegistryMyListResponseSchema, skillRegistryQuoteResponseSchema, skillRegistryPublishResponseSchema, skillRegistryJobStatusResponseSchema, skillRegistryOwnershipResponseSchema, skillRecommendedVersionResponseSchema, skillDeprecationsResponseSchema, skillDeprecationRecordSchema, skillBadgeResponseSchema, skillPreviewRecordSchema, skillPreviewLookupResponseSchema, skillInstallResponseSchema, skillInstallCopyTelemetryResponseSchema, skillRegistryTagsResponseSchema, skillRegistryCategoriesResponseSchema, skillResolverManifestResponseSchema, skillRegistryVoteStatusResponseSchema, skillVerificationRequestCreateResponseSchema, skillVerificationStatusResponseSchema, skillVerificationDomainProofChallengeResponseSchema, skillVerificationDomainProofVerifyResponseSchema } from "./standards-sdk.es160.js";
+async function skillsConfig(client) {
+  const raw = await client.requestJson("/skills/config", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRegistryConfigResponseSchema,
+    "skill registry config response"
+  );
+}
+async function getSkillStatus(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
   }
-  /**
-   * 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
-        };
-      }
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  if (params.version?.trim()) {
+    query.set("version", params.version.trim());
+  }
+  const raw = await client.requestJson(
+    `/skills/status?${query.toString()}`,
+    {
+      method: "GET"
     }
-    if (txBody.systemUndelete) {
-      const systemUndelete = this.parseSystemUndeleteFromProto(
-        txBody.systemUndelete
-      );
-      if (systemUndelete) {
-        return {
-          type: "SYSTEMUNDELETE",
-          humanReadableType: "System Undelete",
-          systemUndelete
-        };
-      }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillStatusResponseSchema,
+    "skill status response"
+  );
+}
+function buildRepoPreviewQuery(params) {
+  const repo = params.repo.trim();
+  const skillDir = params.skillDir.trim();
+  if (!repo) {
+    throw new Error("repo is required");
+  }
+  if (!skillDir) {
+    throw new Error("skillDir is required");
+  }
+  const query = new URLSearchParams();
+  query.set("repo", repo);
+  query.set("skillDir", skillDir);
+  if (params.ref?.trim()) {
+    query.set("ref", params.ref.trim());
+  }
+  return query.toString();
+}
+async function getSkillStatusByRepo(client, params) {
+  const query = buildRepoPreviewQuery(params);
+  const raw = await client.requestJson(
+    `/skills/status/by-repo?${query}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillStatusResponseSchema,
+    "skill status response"
+  );
+}
+async function listSkills(client, params = {}) {
+  const query = new URLSearchParams();
+  if (params.name) {
+    query.set("name", params.name);
+  }
+  if (params.version) {
+    query.set("version", params.version);
+  }
+  if (typeof params.limit === "number" && Number.isFinite(params.limit)) {
+    query.set("limit", String(Math.trunc(params.limit)));
+  }
+  if (params.cursor) {
+    query.set("cursor", params.cursor);
+  }
+  if (typeof params.includeFiles === "boolean") {
+    query.set("includeFiles", params.includeFiles ? "true" : "false");
+  }
+  if (params.accountId) {
+    query.set("accountId", params.accountId);
+  }
+  if (params.q) {
+    query.set("q", params.q);
+  }
+  if (params.tag) {
+    query.set("tag", params.tag);
+  }
+  if (params.category) {
+    query.set("category", params.category);
+  }
+  if (typeof params.featured === "boolean") {
+    query.set("featured", params.featured ? "true" : "false");
+  }
+  if (typeof params.verified === "boolean") {
+    query.set("verified", params.verified ? "true" : "false");
+  }
+  if (params.view) {
+    query.set("view", params.view);
+  }
+  const suffix = query.size > 0 ? `?${query.toString()}` : "";
+  const raw = await client.requestJson(`/skills${suffix}`, {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRegistryListResponseSchema,
+    "skill registry list response"
+  );
+}
+async function getSkillSecurityBreakdown(client, params) {
+  const normalizedJobId = params.jobId.trim();
+  if (!normalizedJobId) {
+    throw new Error("jobId is required");
+  }
+  const raw = await client.requestJson(
+    `/skills/${encodeURIComponent(normalizedJobId)}/security-breakdown`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillSecurityBreakdownResponseSchema,
+    "skill security breakdown response"
+  );
+}
+async function getSkillsCatalog(client, params = {}) {
+  const query = new URLSearchParams();
+  if (params.q) {
+    query.set("q", params.q);
+  }
+  if (params.category) {
+    query.set("category", params.category);
+  }
+  params.tags?.forEach((tag) => {
+    if (tag.trim()) {
+      query.append("tag", tag.trim());
     }
-    if (txBody.nodeCreate) {
-      const nodeCreate = this.parseNodeCreateFromProto(txBody.nodeCreate);
-      if (nodeCreate) {
-        return {
-          type: "NODECREATE",
-          humanReadableType: "Node Create",
-          nodeCreate
-        };
-      }
+  });
+  if (typeof params.featured === "boolean") {
+    query.set("featured", params.featured ? "true" : "false");
+  }
+  if (typeof params.verified === "boolean") {
+    query.set("verified", params.verified ? "true" : "false");
+  }
+  if (params.channel) {
+    query.set("channel", params.channel);
+  }
+  if (params.sortBy) {
+    query.set("sortBy", params.sortBy);
+  }
+  if (typeof params.limit === "number" && Number.isFinite(params.limit)) {
+    query.set("limit", String(Math.trunc(params.limit)));
+  }
+  if (params.cursor) {
+    query.set("cursor", params.cursor);
+  }
+  const suffix = query.size > 0 ? `?${query.toString()}` : "";
+  const raw = await client.requestJson(`/skills/catalog${suffix}`, {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    skillCatalogResponseSchema,
+    "skill catalog response"
+  );
+}
+async function listSkillVersions(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  const raw = await client.requestJson(
+    `/skills/versions?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillRegistryVersionsResponseSchema,
+    "skill registry versions response"
+  );
+}
+async function listMySkills(client, params = {}) {
+  const query = new URLSearchParams();
+  if (typeof params.limit === "number" && Number.isFinite(params.limit)) {
+    query.set("limit", String(Math.trunc(params.limit)));
+  }
+  const suffix = query.size > 0 ? `?${query.toString()}` : "";
+  const raw = await client.requestJson(`/skills/mine${suffix}`, {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRegistryMineResponseSchema,
+    "skill registry mine response"
+  );
+}
+async function getMySkillsList(client, params = {}) {
+  const query = new URLSearchParams();
+  if (typeof params.limit === "number" && Number.isFinite(params.limit)) {
+    query.set("limit", String(Math.trunc(params.limit)));
+  }
+  if (params.cursor) {
+    query.set("cursor", params.cursor);
+  }
+  if (params.accountId) {
+    query.set("accountId", params.accountId);
+  }
+  const suffix = query.size > 0 ? `?${query.toString()}` : "";
+  const raw = await client.requestJson(`/skills/my-list${suffix}`, {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRegistryMyListResponseSchema,
+    "skill registry my list response"
+  );
+}
+async function quoteSkillPublish(client, payload) {
+  const raw = await client.requestJson("/skills/quote", {
+    method: "POST",
+    body: payload,
+    headers: { "content-type": "application/json" }
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRegistryQuoteResponseSchema,
+    "skill registry quote response"
+  );
+}
+async function publishSkill(client, payload) {
+  const raw = await client.requestJson("/skills/publish", {
+    method: "POST",
+    body: payload,
+    headers: { "content-type": "application/json" }
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRegistryPublishResponseSchema,
+    "skill registry publish response"
+  );
+}
+async function getSkillPublishJob(client, jobId, params = {}) {
+  const normalized = jobId.trim();
+  if (!normalized) {
+    throw new Error("jobId is required");
+  }
+  const query = new URLSearchParams();
+  if (params.accountId) {
+    query.set("accountId", params.accountId);
+  }
+  const suffix = query.size > 0 ? `?${query.toString()}` : "";
+  const raw = await client.requestJson(
+    `/skills/jobs/${encodeURIComponent(normalized)}${suffix}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillRegistryJobStatusResponseSchema,
+    "skill registry job status response"
+  );
+}
+async function getSkillOwnership(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  if (params.accountId) {
+    query.set("accountId", params.accountId);
+  }
+  const raw = await client.requestJson(
+    `/skills/ownership?${query.toString()}`,
+    {
+      method: "GET"
     }
-    if (txBody.nodeUpdate) {
-      const nodeUpdate = this.parseNodeUpdateFromProto(txBody.nodeUpdate);
-      if (nodeUpdate) {
-        return {
-          type: "NODEUPDATE",
-          humanReadableType: "Node Update",
-          nodeUpdate
-        };
+  );
+  return client.parseWithSchema(
+    raw,
+    skillRegistryOwnershipResponseSchema,
+    "skill registry ownership response"
+  );
+}
+async function getRecommendedSkillVersion(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  const raw = await client.requestJson(
+    `/skills/recommended?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillRecommendedVersionResponseSchema,
+    "skill recommended version response"
+  );
+}
+async function setRecommendedSkillVersion(client, payload) {
+  const normalizedName = payload.name.trim();
+  const normalizedVersion = payload.version.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  if (!normalizedVersion) {
+    throw new Error("version is required");
+  }
+  const raw = await client.requestJson("/skills/recommended", {
+    method: "POST",
+    body: {
+      name: normalizedName,
+      version: normalizedVersion
+    },
+    headers: { "content-type": "application/json" }
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRecommendedVersionResponseSchema,
+    "skill recommended version response"
+  );
+}
+async function getSkillDeprecations(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  const raw = await client.requestJson(
+    `/skills/deprecations?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillDeprecationsResponseSchema,
+    "skill deprecations response"
+  );
+}
+async function setSkillDeprecation(client, payload) {
+  const normalizedName = payload.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const version = payload.version?.trim();
+  const reason = payload.reason.trim();
+  if (!reason) {
+    throw new Error("reason is required");
+  }
+  const replacementRef = payload.replacementRef?.trim();
+  const raw = await client.requestJson("/skills/deprecate", {
+    method: "POST",
+    body: {
+      name: normalizedName,
+      version,
+      reason,
+      replacementRef
+    },
+    headers: { "content-type": "application/json" }
+  });
+  return client.parseWithSchema(
+    raw,
+    skillDeprecationRecordSchema,
+    "skill deprecation response"
+  );
+}
+async function getSkillBadge(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  if (params.metric) {
+    query.set("metric", params.metric);
+  }
+  if (params.label?.trim()) {
+    query.set("label", params.label.trim());
+  }
+  if (params.style) {
+    query.set("style", params.style);
+  }
+  const raw = await client.requestJson(
+    `/skills/badge?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillBadgeResponseSchema,
+    "skill badge response"
+  );
+}
+async function uploadSkillPreviewFromGithubOidc(client, payload) {
+  const token = payload.token.trim();
+  if (!token) {
+    throw new Error("token is required");
+  }
+  const raw = await client.requestJson(
+    "/skills/preview/github-oidc",
+    {
+      method: "POST",
+      body: payload.report,
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`
       }
     }
-    if (txBody.nodeDelete) {
-      const nodeDelete = this.parseNodeDeleteFromProto(txBody.nodeDelete);
-      if (nodeDelete) {
-        return {
-          type: "NODEDELETE",
-          humanReadableType: "Node Delete",
-          nodeDelete
-        };
-      }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewRecordSchema,
+    "skill preview record response"
+  );
+}
+async function getSkillPreview(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  if (params.version?.trim()) {
+    query.set("version", params.version.trim());
+  }
+  const raw = await client.requestJson(
+    `/skills/preview?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewLookupResponseSchema,
+    "skill preview response"
+  );
+}
+async function getSkillPreviewByRepo(client, params) {
+  const query = buildRepoPreviewQuery(params);
+  const raw = await client.requestJson(
+    `/skills/preview/by-repo?${query}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewLookupResponseSchema,
+    "skill preview by repo response"
+  );
+}
+async function getSkillPreviewById(client, previewId) {
+  const normalizedPreviewId = previewId.trim();
+  if (!normalizedPreviewId) {
+    throw new Error("previewId is required");
+  }
+  const raw = await client.requestJson(
+    `/skills/preview/${encodeURIComponent(normalizedPreviewId)}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewLookupResponseSchema,
+    "skill preview by id response"
+  );
+}
+async function getSkillInstall(client, skillRef) {
+  const normalizedSkillRef = skillRef.trim();
+  if (!normalizedSkillRef) {
+    throw new Error("skillRef is required");
+  }
+  const raw = await client.requestJson(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/install`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillInstallResponseSchema,
+    "skill install response"
+  );
+}
+async function recordSkillInstallCopy(client, skillRef, payload = {}) {
+  const normalizedSkillRef = skillRef.trim();
+  if (!normalizedSkillRef) {
+    throw new Error("skillRef is required");
+  }
+  const raw = await client.requestJson(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/telemetry/install-copy`,
+    {
+      method: "POST",
+      body: payload,
+      headers: { "content-type": "application/json" }
     }
-    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 client.parseWithSchema(
+    raw,
+    skillInstallCopyTelemetryResponseSchema,
+    "skill install copy telemetry response"
+  );
+}
+async function listSkillTags(client) {
+  const raw = await client.requestJson("/skills/tags", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRegistryTagsResponseSchema,
+    "skill tags response"
+  );
+}
+async function listSkillCategories(client) {
+  const raw = await client.requestJson("/skills/categories", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRegistryCategoriesResponseSchema,
+    "skill categories response"
+  );
+}
+async function resolveSkillMarkdown(client, skillRef) {
+  const normalizedSkillRef = skillRef.trim();
+  if (!normalizedSkillRef) {
+    throw new Error("skillRef is required");
+  }
+  const response = await client.request(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/SKILL.md`,
+    {
+      method: "GET",
+      headers: {
+        accept: "text/markdown, text/plain;q=0.9, */*;q=0.8"
       }
-      return {};
-    } catch (error) {
-      return {};
     }
+  );
+  return response.text();
+}
+async function resolveSkillManifest(client, skillRef) {
+  const normalizedSkillRef = skillRef.trim();
+  if (!normalizedSkillRef) {
+    throw new Error("skillRef is required");
   }
-  /**
-   * 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();
+  const raw = await client.requestJson(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/manifest`,
+    {
+      method: "GET"
     }
-    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;
+  );
+  return client.parseWithSchema(
+    raw,
+    skillResolverManifestResponseSchema,
+    "skill resolver manifest response"
+  );
+}
+async function getSkillVoteStatus(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  const raw = await client.requestJson(
+    `/skills/vote?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillRegistryVoteStatusResponseSchema,
+    "skill registry vote status response"
+  );
+}
+async function setSkillVote(client, payload) {
+  const normalizedName = payload.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  const raw = await client.requestJson("/skills/vote", {
+    method: "POST",
+    body: { name: normalizedName, upvoted: payload.upvoted },
+    headers: { "content-type": "application/json" }
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRegistryVoteStatusResponseSchema,
+    "skill registry vote status response"
+  );
+}
+async function requestSkillVerification(client, payload) {
+  const normalizedName = payload.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
   }
-  static parseUtilPrng(body) {
-    if (!body) return void 0;
-    const data = {};
-    if (body.range && body.range !== 0) {
-      data.range = body.range;
+  const raw = await client.requestJson(
+    "/skills/verification/request",
+    {
+      method: "POST",
+      body: {
+        name: normalizedName,
+        version: payload.version,
+        tier: payload.tier
+      },
+      headers: { "content-type": "application/json" }
     }
-    return data;
+  );
+  return client.parseWithSchema(
+    raw,
+    skillVerificationRequestCreateResponseSchema,
+    "skill verification request create response"
+  );
+}
+async function getSkillVerificationStatus(client, params) {
+  const normalizedName = params.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
   }
-  static parseFreeze(body) {
-    return this.parseNetworkFreezeFromProto(body);
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  if (params.version) {
+    query.set("version", params.version);
   }
-  /**
-   * 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);
+  const raw = await client.requestJson(
+    `/skills/verification/status?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillVerificationStatusResponseSchema,
+    "skill verification status response"
+  );
+}
+async function createSkillDomainProofChallenge(client, payload) {
+  const normalizedName = payload.name.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
   }
+  const raw = await client.requestJson(
+    "/skills/verification/domain/challenge",
+    {
+      method: "POST",
+      body: {
+        name: normalizedName,
+        version: payload.version,
+        domain: payload.domain
+      },
+      headers: { "content-type": "application/json" }
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillVerificationDomainProofChallengeResponseSchema,
+    "skill domain proof challenge response"
+  );
+}
+async function verifySkillDomainProof(client, payload) {
+  const normalizedName = payload.name.trim();
+  const challengeToken = payload.challengeToken.trim();
+  if (!normalizedName) {
+    throw new Error("name is required");
+  }
+  if (!challengeToken) {
+    throw new Error("challengeToken is required");
+  }
+  const raw = await client.requestJson(
+    "/skills/verification/domain/verify",
+    {
+      method: "POST",
+      body: {
+        name: normalizedName,
+        version: payload.version,
+        domain: payload.domain,
+        challengeToken
+      },
+      headers: { "content-type": "application/json" }
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillVerificationDomainProofVerifyResponseSchema,
+    "skill domain proof verify response"
+  );
 }
 export {
-  UtilParser
+  createSkillDomainProofChallenge,
+  getMySkillsList,
+  getRecommendedSkillVersion,
+  getSkillBadge,
+  getSkillDeprecations,
+  getSkillInstall,
+  getSkillOwnership,
+  getSkillPreview,
+  getSkillPreviewById,
+  getSkillPreviewByRepo,
+  getSkillPublishJob,
+  getSkillSecurityBreakdown,
+  getSkillStatus,
+  getSkillStatusByRepo,
+  getSkillVerificationStatus,
+  getSkillVoteStatus,
+  getSkillsCatalog,
+  listMySkills,
+  listSkillCategories,
+  listSkillTags,
+  listSkillVersions,
+  listSkills,
+  publishSkill,
+  quoteSkillPublish,
+  recordSkillInstallCopy,
+  requestSkillVerification,
+  resolveSkillManifest,
+  resolveSkillMarkdown,
+  setRecommendedSkillVersion,
+  setSkillDeprecation,
+  setSkillVote,
+  skillsConfig,
+  uploadSkillPreviewFromGithubOidc,
+  verifySkillDomainProof
 };
 //# sourceMappingURL=standards-sdk.es167.js.map