@hashgraphonline/standards-sdk 0.1.187 → 0.1.189

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

@@ -1,203 +1,675 @@
-import { parseSemicolonFields } from "./standards-sdk.es189.js";
-const ANS_HCS27_REGISTRY = "ans";
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function asString(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return null;
-  }
-  return trimmed;
-}
-function isSemver(value) {
-  return /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(
-    value
-  );
-}
-function normalizeAnsVersion(value) {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return null;
-  }
-  const withoutPrefix = trimmed.startsWith("v") || trimmed.startsWith("V") ? trimmed.slice(1) : trimmed;
-  if (!isSemver(withoutPrefix)) {
-    return null;
-  }
-  return withoutPrefix;
-}
-function parseAnsDnsTxtRecord(rawRecord) {
-  const fields = parseSemicolonFields(rawRecord);
-  const version = fields["v"];
-  const urlValue = fields["url"];
-  if (!version || !urlValue || version.toLowerCase() !== "ans1") {
-    return null;
-  }
-  let parsedUrl;
-  try {
-    parsedUrl = new URL(urlValue);
-  } catch {
-    return null;
-  }
-  if (parsedUrl.protocol.toLowerCase() !== "https:") {
-    return null;
-  }
-  const rawAnsVersion = fields["version"];
-  let normalizedAnsVersion;
-  if (rawAnsVersion !== void 0) {
-    const parsedVersion = normalizeAnsVersion(rawAnsVersion);
-    if (!parsedVersion) {
-      return null;
+import { skillRegistryConfigResponseSchema, skillRegistryListResponseSchema, skillCatalogResponseSchema, skillRegistryVersionsResponseSchema, skillRegistryMineResponseSchema, skillRegistryMyListResponseSchema, skillRegistryQuoteResponseSchema, skillQuotePreviewResponseSchema, skillRegistryPublishResponseSchema, skillRegistryJobStatusResponseSchema, skillRegistryOwnershipResponseSchema, skillRecommendedVersionResponseSchema, skillDeprecationsResponseSchema, skillDeprecationRecordSchema, skillBadgeResponseSchema, skillStatusResponseSchema, skillSecurityBreakdownResponseSchema, skillConversionSignalsResponseSchema, skillPreviewRecordSchema, skillPreviewLookupResponseSchema, skillInstallResponseSchema, skillInstallCopyTelemetryResponseSchema, skillRegistryTagsResponseSchema, skillRegistryCategoriesResponseSchema, skillResolverManifestResponseSchema, skillRegistryVoteStatusResponseSchema, skillVerificationRequestCreateResponseSchema, skillVerificationStatusResponseSchema, skillVerificationDomainProofChallengeResponseSchema, skillVerificationDomainProofVerifyResponseSchema } from "./standards-sdk.es158.js";
+function requireTrimmedString(value, fieldName) {
+  const normalizedValue = value.trim();
+  if (!normalizedValue) {
+    throw new Error(`${fieldName} is required`);
+  }
+  return normalizedValue;
+}
+async function skillsConfig(client) {
+  const raw = await client.requestJson("/skills/config", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    skillRegistryConfigResponseSchema,
+    "skill registry config 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 = requireTrimmedString(params.jobId, "jobId");
+  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 (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 = requireTrimmedString(params.name, "name");
+  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 quoteSkillPublishPreview(client, payload) {
+  const raw = await client.requestJson("/skills/quote-preview", {
+    method: "POST",
+    body: payload,
+    headers: { "content-type": "application/json" }
+  });
+  return client.parseWithSchema(
+    raw,
+    skillQuotePreviewResponseSchema,
+    "skill quote preview 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 = requireTrimmedString(jobId, "jobId");
+  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 = requireTrimmedString(params.name, "name");
+  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"
     }
-    normalizedAnsVersion = parsedVersion;
+  );
+  return client.parseWithSchema(
+    raw,
+    skillRegistryOwnershipResponseSchema,
+    "skill registry ownership response"
+  );
+}
+async function getRecommendedSkillVersion(client, params) {
+  const normalizedName = requireTrimmedString(params.name, "name");
+  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 = requireTrimmedString(payload.name, "name");
+  const normalizedVersion = requireTrimmedString(payload.version, "version");
+  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 = requireTrimmedString(params.name, "name");
+  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 = requireTrimmedString(payload.name, "name");
+  const version = payload.version?.trim();
+  const reason = requireTrimmedString(payload.reason, "reason");
+  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 = requireTrimmedString(params.name, "name");
+  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 getSkillStatus(client, params) {
+  const normalizedName = requireTrimmedString(params.name, "name");
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  if (params.version?.trim()) {
+    query.set("version", params.version.trim());
   }
-  return {
-    version: normalizedAnsVersion,
-    url: parsedUrl.toString()
-  };
+  const raw = await client.requestJson(
+    `/skills/status?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillStatusResponseSchema,
+    "skill status response"
+  );
 }
-function isValidAnsProfileVersion(value) {
-  return !!value && normalizeAnsVersion(value) !== null;
+async function getSkillStatusByRepo(client, params) {
+  const repo = requireTrimmedString(params.repo, "repo");
+  const skillDir = requireTrimmedString(params.skillDir, "skillDir");
+  const query = new URLSearchParams();
+  query.set("repo", repo);
+  query.set("skillDir", skillDir);
+  if (params.ref?.trim()) {
+    query.set("ref", params.ref.trim());
+  }
+  const raw = await client.requestJson(
+    `/skills/status/by-repo?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillStatusResponseSchema,
+    "skill status response"
+  );
 }
-function hasProtocolPathSegment(pathname, protocol) {
-  const normalizedProtocol = protocol.trim().toLowerCase();
-  if (!normalizedProtocol) {
-    return false;
+async function getSkillConversionSignalsByRepo(client, params) {
+  const repo = requireTrimmedString(params.repo, "repo");
+  const skillDir = requireTrimmedString(params.skillDir, "skillDir");
+  const query = new URLSearchParams();
+  query.set("repo", repo);
+  query.set("skillDir", skillDir);
+  if (params.ref?.trim()) {
+    query.set("ref", params.ref.trim());
   }
-  const pathSegments = pathname.split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
-  for (const segment of pathSegments) {
-    if (segment.toLowerCase() === normalizedProtocol) {
-      return true;
+  const raw = await client.requestJson(
+    `/skills/conversion-signals/by-repo?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillConversionSignalsResponseSchema,
+    "skill conversion signals response"
+  );
+}
+async function uploadSkillPreviewFromGithubOidc(client, payload) {
+  const token = requireTrimmedString(payload.token, "token");
+  const raw = await client.requestJson(
+    "/skills/preview/github-oidc",
+    {
+      method: "POST",
+      body: payload.report,
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`
+      }
     }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewRecordSchema,
+    "skill preview record response"
+  );
+}
+async function getSkillPreview(client, params) {
+  const normalizedName = requireTrimmedString(params.name, "name");
+  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 repo = requireTrimmedString(params.repo, "repo");
+  const skillDir = requireTrimmedString(params.skillDir, "skillDir");
+  const query = new URLSearchParams();
+  query.set("repo", repo);
+  query.set("skillDir", skillDir);
+  if (params.ref?.trim()) {
+    query.set("ref", params.ref.trim());
   }
-  return false;
+  const raw = await client.requestJson(
+    `/skills/preview/by-repo?${query.toString()}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillPreviewLookupResponseSchema,
+    "skill preview by repo response"
+  );
+}
+async function getSkillPreviewById(client, previewId) {
+  const normalizedPreviewId = requireTrimmedString(previewId, "previewId");
+  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 = requireTrimmedString(skillRef, "skillRef");
+  const raw = await client.requestJson(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/install`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillInstallResponseSchema,
+    "skill install response"
+  );
 }
-function extractEndpointCandidates(endpoints, supportedSchemes) {
-  const candidates = [];
-  for (const [key, value] of Object.entries(endpoints)) {
-    if (!isObjectRecord(value)) {
-      continue;
+async function recordSkillInstallCopy(client, skillRef, payload = {}) {
+  const normalizedSkillRef = requireTrimmedString(skillRef, "skillRef");
+  const raw = await client.requestJson(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/telemetry/install-copy`,
+    {
+      method: "POST",
+      body: payload,
+      headers: { "content-type": "application/json" }
     }
-    const endpoint = asString(value["url"]);
-    if (!endpoint) {
-      continue;
+  );
+  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 = requireTrimmedString(skillRef, "skillRef");
+  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 response.text();
+}
+async function resolveSkillManifest(client, skillRef) {
+  const normalizedSkillRef = requireTrimmedString(skillRef, "skillRef");
+  const raw = await client.requestJson(
+    `/skills/${encodeURIComponent(normalizedSkillRef)}/manifest`,
+    {
+      method: "GET"
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    skillResolverManifestResponseSchema,
+    "skill resolver manifest response"
+  );
+}
+async function getSkillVoteStatus(client, params) {
+  const normalizedName = requireTrimmedString(params.name, "name");
+  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 = requireTrimmedString(payload.name, "name");
+  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 = requireTrimmedString(payload.name, "name");
+  const raw = await client.requestJson(
+    "/skills/verification/request",
+    {
+      method: "POST",
+      body: {
+        name: normalizedName,
+        version: payload.version,
+        tier: payload.tier
+      },
+      headers: { "content-type": "application/json" }
     }
-    let parsedUrl;
-    try {
-      parsedUrl = new URL(endpoint);
-    } catch {
-      continue;
+  );
+  return client.parseWithSchema(
+    raw,
+    skillVerificationRequestCreateResponseSchema,
+    "skill verification request create response"
+  );
+}
+async function getSkillVerificationStatus(client, params) {
+  const normalizedName = requireTrimmedString(params.name, "name");
+  const query = new URLSearchParams();
+  query.set("name", normalizedName);
+  if (params.version) {
+    query.set("version", params.version);
+  }
+  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 = requireTrimmedString(payload.name, "name");
+  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" }
     }
-    const scheme = parsedUrl.protocol.replace(/:$/, "").toLowerCase();
-    if (!supportedSchemes.has(scheme)) {
-      continue;
+  );
+  return client.parseWithSchema(
+    raw,
+    skillVerificationDomainProofChallengeResponseSchema,
+    "skill domain proof challenge response"
+  );
+}
+async function verifySkillDomainProof(client, payload) {
+  const normalizedName = requireTrimmedString(payload.name, "name");
+  const challengeToken = requireTrimmedString(
+    payload.challengeToken,
+    "challengeToken"
+  );
+  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" }
     }
-    candidates.push({
-      key,
-      endpointUrl: parsedUrl.toString(),
-      parsedUrl
-    });
-  }
-  return candidates;
-}
-function validateAnsHcs27Hints(input) {
-  if (!isObjectRecord(input)) {
-    return void 0;
-  }
-  const checkpointTopicId = asString(input["checkpoint_topic_id"]);
-  const registry = asString(input["registry"]);
-  const logId = asString(input["log_id"]);
-  if (!checkpointTopicId || !registry || !logId || registry !== ANS_HCS27_REGISTRY) {
-    return void 0;
-  }
-  const checkpointUri = asString(input["checkpoint_uri"]) ?? void 0;
-  const viewerUri = asString(input["viewer_uri"]) ?? void 0;
-  return {
-    checkpointTopicId,
-    registry,
-    logId,
-    checkpointUri,
-    viewerUri
-  };
-}
-function validateHcs28Hints(input) {
-  if (!isObjectRecord(input)) {
-    return void 0;
-  }
-  const directoryTopicId = asString(input["directory_topic_id"]);
-  const tId = asString(input["t_id"]);
-  const agentId = asString(input["agent_id"]);
-  if (!directoryTopicId || !tId || !agentId) {
-    return void 0;
-  }
-  const proofProfile = asString(input["proof_profile"]) ?? void 0;
-  return {
-    directoryTopicId,
-    tId,
-    agentId,
-    proofProfile
-  };
-}
-function parseTransparencyHints(input) {
-  if (!isObjectRecord(input)) {
-    return void 0;
-  }
-  const hcs27 = validateAnsHcs27Hints(input["hcs27"]);
-  const hcs28 = validateHcs28Hints(input["hcs28"]);
-  if (!hcs27 && !hcs28) {
-    return void 0;
-  }
-  return {
-    hcs27,
-    hcs28
-  };
-}
-function parseAnsAgentCard(input) {
-  if (!isObjectRecord(input)) {
-    return null;
-  }
-  const ansName = asString(input["ansName"]);
-  const endpoints = input["endpoints"];
-  if (!ansName || !isObjectRecord(endpoints)) {
-    return null;
-  }
-  return {
-    ansName,
-    endpoints,
-    transparencyHints: parseTransparencyHints(input["transparency"])
-  };
-}
-function selectPreferredEndpoint(candidates, protocol) {
-  if (candidates.length === 0) {
-    return null;
-  }
-  const sortedCandidates = [...candidates].sort(
-    (a, b) => a.key.localeCompare(b.key)
-  );
-  const protocolMatches = sortedCandidates.filter(
-    (candidate) => hasProtocolPathSegment(candidate.parsedUrl.pathname, protocol)
-  );
-  if (protocolMatches.length > 0) {
-    return protocolMatches[0];
-  }
-  return sortedCandidates[0];
-}
-function toErrorMessage(error) {
-  if (error instanceof Error && error.message) {
-    return error.message;
-  }
-  return null;
+  );
+  return client.parseWithSchema(
+    raw,
+    skillVerificationDomainProofVerifyResponseSchema,
+    "skill domain proof verify response"
+  );
 }
 export {
-  extractEndpointCandidates,
-  isValidAnsProfileVersion,
-  normalizeAnsVersion,
-  parseAnsAgentCard,
-  parseAnsDnsTxtRecord,
-  selectPreferredEndpoint,
-  toErrorMessage
+  createSkillDomainProofChallenge,
+  getMySkillsList,
+  getRecommendedSkillVersion,
+  getSkillBadge,
+  getSkillConversionSignalsByRepo,
+  getSkillDeprecations,
+  getSkillInstall,
+  getSkillOwnership,
+  getSkillPreview,
+  getSkillPreviewById,
+  getSkillPreviewByRepo,
+  getSkillPublishJob,
+  getSkillSecurityBreakdown,
+  getSkillStatus,
+  getSkillStatusByRepo,
+  getSkillVerificationStatus,
+  getSkillVoteStatus,
+  getSkillsCatalog,
+  listMySkills,
+  listSkillCategories,
+  listSkillTags,
+  listSkillVersions,
+  listSkills,
+  publishSkill,
+  quoteSkillPublish,
+  quoteSkillPublishPreview,
+  recordSkillInstallCopy,
+  requestSkillVerification,
+  resolveSkillManifest,
+  resolveSkillMarkdown,
+  setRecommendedSkillVersion,
+  setSkillDeprecation,
+  setSkillVote,
+  skillsConfig,
+  uploadSkillPreviewFromGithubOidc,
+  verifySkillDomainProof
 };
 //# sourceMappingURL=standards-sdk.es190.js.map