@hol-org/rb-client 0.1.163 → 0.1.165

package/dist/index.cjs

@@ -1123,6 +1123,26 @@ var verificationVerifySenderResponseSchema = import_zod2.z.object({
   ownerType: import_zod2.z.string(),
   ownerId: import_zod2.z.string()
 }).passthrough();
+var verificationDnsErrorSchema = import_zod2.z.object({
+  code: import_zod2.z.string(),
+  message: import_zod2.z.string(),
+  details: import_zod2.z.record(jsonValueSchema).optional()
+}).passthrough();
+var verificationDnsStatusResponseSchema = import_zod2.z.object({
+  uaid: import_zod2.z.string(),
+  verified: import_zod2.z.boolean(),
+  profileId: import_zod2.z.string(),
+  checkedAt: import_zod2.z.string(),
+  nativeId: import_zod2.z.string().optional(),
+  dnsName: import_zod2.z.string().optional(),
+  verificationLevel: import_zod2.z.string().optional(),
+  resolutionMode: import_zod2.z.string().optional(),
+  reconstructedUaid: import_zod2.z.string().optional(),
+  selectedFollowupProfile: import_zod2.z.string().optional(),
+  error: verificationDnsErrorSchema.optional(),
+  source: import_zod2.z.string().optional(),
+  persisted: import_zod2.z.boolean().optional()
+}).passthrough();
 var registerStatusResponseSchema = import_zod2.z.object({
   registered: import_zod2.z.boolean(),
   agent: jsonValueSchema.optional()
@@ -1199,6 +1219,102 @@ var skillRegistryListResponseSchema = import_zod2.z.object({
   items: import_zod2.z.array(skillRegistryPublishSummarySchema),
   nextCursor: import_zod2.z.string().nullable()
 }).passthrough();
+var skillSecurityBreakdownResponseSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  version: import_zod2.z.string(),
+  jobId: import_zod2.z.string(),
+  createdAt: import_zod2.z.string(),
+  safety: skillSafetySummarySchema.nullable(),
+  findings: import_zod2.z.array(skillSafetyFindingSchema)
+}).passthrough();
+var skillCatalogChannelSchema = import_zod2.z.enum([
+  "stable",
+  "prerelease",
+  "all"
+]);
+var skillCatalogSortBySchema = import_zod2.z.enum([
+  "trending",
+  "upvotes",
+  "updated",
+  "name"
+]);
+var skillCatalogVersionSummarySchema = import_zod2.z.object({
+  version: import_zod2.z.string(),
+  publishedAt: import_zod2.z.string(),
+  verified: import_zod2.z.boolean().optional()
+}).passthrough();
+var skillCatalogItemSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  description: import_zod2.z.string().optional(),
+  iconHcs1: import_zod2.z.string().optional(),
+  category: import_zod2.z.string().optional(),
+  tags: import_zod2.z.array(import_zod2.z.string()).optional(),
+  latest: skillCatalogVersionSummarySchema,
+  latestStable: skillCatalogVersionSummarySchema.optional(),
+  recommended: skillCatalogVersionSummarySchema,
+  upvotes: import_zod2.z.number().int(),
+  verified: import_zod2.z.boolean(),
+  repoStamped: import_zod2.z.boolean(),
+  trustScore: import_zod2.z.number().optional(),
+  safetyScore: import_zod2.z.number().optional()
+}).passthrough();
+var skillCatalogResponseSchema = import_zod2.z.object({
+  items: import_zod2.z.array(skillCatalogItemSchema),
+  nextCursor: import_zod2.z.string().nullable()
+}).passthrough();
+var skillRecommendedVersionResponseSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  version: import_zod2.z.string(),
+  updatedAt: import_zod2.z.string(),
+  setBy: import_zod2.z.string()
+}).passthrough();
+var skillDeprecationRecordSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  version: import_zod2.z.string().optional(),
+  reason: import_zod2.z.string(),
+  replacementRef: import_zod2.z.string().optional(),
+  deprecatedAt: import_zod2.z.string(),
+  deprecatedBy: import_zod2.z.string()
+}).passthrough();
+var skillDeprecationsResponseSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  items: import_zod2.z.array(skillDeprecationRecordSchema)
+}).passthrough();
+var skillBadgeMetricSchema = import_zod2.z.enum([
+  "version",
+  "status",
+  "verification",
+  "repo_commit",
+  "manifest",
+  "domain",
+  "trust",
+  "safety",
+  "upvotes",
+  "updated"
+]);
+var skillBadgeStyleSchema = import_zod2.z.enum([
+  "flat",
+  "flat-square",
+  "for-the-badge",
+  "plastic",
+  "social"
+]);
+var skillBadgeResponseSchema = import_zod2.z.object({
+  schemaVersion: import_zod2.z.number().int(),
+  label: import_zod2.z.string(),
+  message: import_zod2.z.string(),
+  color: import_zod2.z.string(),
+  style: skillBadgeStyleSchema.optional(),
+  isError: import_zod2.z.boolean().optional(),
+  cacheSeconds: import_zod2.z.number().int().optional()
+}).passthrough();
+var skillRegistryTagsResponseSchema = import_zod2.z.object({
+  tags: import_zod2.z.array(import_zod2.z.string())
+}).passthrough();
+var skillRegistryCategoriesResponseSchema = import_zod2.z.object({
+  categories: import_zod2.z.array(import_zod2.z.string())
+}).passthrough();
+var skillResolverManifestResponseSchema = import_zod2.z.record(jsonValueSchema);
 var skillRegistryQuoteFileBreakdownSchema = import_zod2.z.object({
   name: import_zod2.z.string(),
   mimeType: import_zod2.z.string(),
@@ -1307,6 +1423,81 @@ var skillVerificationStatusSchema = import_zod2.z.enum([
   "approved",
   "rejected"
 ]);
+var skillVerificationStatusLabelSchema = import_zod2.z.enum([
+  "not_requested",
+  "pending",
+  "approved",
+  "rejected"
+]);
+var skillVerificationSignalFailureReasonSchema = import_zod2.z.enum([
+  "missing_owner",
+  "missing_repo_or_commit",
+  "unsupported_repo",
+  "repo_fetch_failed",
+  "manifest_pointer_missing",
+  "manifest_fetch_failed",
+  "manifest_parse_failed",
+  "missing_file_hashes",
+  "missing_domain",
+  "challenge_invalid",
+  "challenge_expired",
+  "dns_lookup_failed",
+  "dns_record_missing",
+  "mismatch"
+]);
+var skillVerificationPublisherBoundSignalSchema = import_zod2.z.object({
+  ok: import_zod2.z.boolean(),
+  ownerAccountId: import_zod2.z.string().nullable(),
+  ownerUserId: import_zod2.z.string().nullable(),
+  checkedAt: import_zod2.z.string(),
+  reason: skillVerificationSignalFailureReasonSchema.optional()
+}).passthrough();
+var skillVerificationRepoCommitIntegrityMismatchSchema = import_zod2.z.object({
+  path: import_zod2.z.string(),
+  expectedSha256: import_zod2.z.string(),
+  actualSha256: import_zod2.z.string().optional(),
+  error: import_zod2.z.string().optional()
+}).passthrough();
+var skillVerificationRepoCommitIntegritySignalSchema = import_zod2.z.object({
+  ok: import_zod2.z.boolean(),
+  repo: import_zod2.z.string().nullable(),
+  commit: import_zod2.z.string().nullable(),
+  checkedAt: import_zod2.z.string(),
+  filesChecked: import_zod2.z.number().int().min(0),
+  mismatches: import_zod2.z.array(skillVerificationRepoCommitIntegrityMismatchSchema),
+  partial: import_zod2.z.boolean().optional(),
+  reason: skillVerificationSignalFailureReasonSchema.optional()
+}).passthrough();
+var skillVerificationManifestIntegrityShaMismatchSchema = import_zod2.z.object({
+  path: import_zod2.z.string(),
+  expectedSha256: import_zod2.z.string(),
+  actualSha256: import_zod2.z.string().optional()
+}).passthrough();
+var skillVerificationManifestIntegritySignalSchema = import_zod2.z.object({
+  ok: import_zod2.z.boolean(),
+  manifestHrl: import_zod2.z.string().nullable(),
+  manifestSha256: import_zod2.z.string().nullable(),
+  checkedAt: import_zod2.z.string(),
+  missingFiles: import_zod2.z.array(import_zod2.z.string()),
+  shaMismatches: import_zod2.z.array(skillVerificationManifestIntegrityShaMismatchSchema),
+  extraFiles: import_zod2.z.array(import_zod2.z.string()).optional(),
+  reason: skillVerificationSignalFailureReasonSchema.optional()
+}).passthrough();
+var skillVerificationDomainProofSignalSchema = import_zod2.z.object({
+  ok: import_zod2.z.boolean(),
+  domain: import_zod2.z.string().optional(),
+  method: import_zod2.z.literal("dns_txt").optional(),
+  checkedAt: import_zod2.z.string().optional(),
+  details: import_zod2.z.string().optional(),
+  txtRecordName: import_zod2.z.string().optional(),
+  reason: skillVerificationSignalFailureReasonSchema.optional()
+}).passthrough();
+var skillVerificationSignalsSchema = import_zod2.z.object({
+  publisherBound: skillVerificationPublisherBoundSignalSchema,
+  repoCommitIntegrity: skillVerificationRepoCommitIntegritySignalSchema,
+  manifestIntegrity: skillVerificationManifestIntegritySignalSchema,
+  domainProof: skillVerificationDomainProofSignalSchema.optional()
+}).passthrough();
 var skillVerificationRequestSchema = import_zod2.z.object({
   id: import_zod2.z.string(),
   network: import_zod2.z.union([import_zod2.z.literal("mainnet"), import_zod2.z.literal("testnet")]),
@@ -1317,6 +1508,8 @@ var skillVerificationRequestSchema = import_zod2.z.object({
   usdCents: import_zod2.z.number(),
   creditsCharged: import_zod2.z.number(),
   creditAccountId: import_zod2.z.string().optional(),
+  signals: skillVerificationSignalsSchema.optional(),
+  reviewNotes: import_zod2.z.string().optional(),
   requestedBy: import_zod2.z.object({
     userId: import_zod2.z.string().optional(),
     accountId: import_zod2.z.string().optional(),
@@ -1327,6 +1520,11 @@ var skillVerificationRequestSchema = import_zod2.z.object({
     email: import_zod2.z.string().optional()
   }).optional(),
   approvedAt: import_zod2.z.string().optional(),
+  rejectedBy: import_zod2.z.object({
+    userId: import_zod2.z.string().optional(),
+    email: import_zod2.z.string().optional()
+  }).optional(),
+  rejectedAt: import_zod2.z.string().optional(),
   createdAt: import_zod2.z.string(),
   updatedAt: import_zod2.z.string()
 }).passthrough();
@@ -1335,10 +1533,40 @@ var skillVerificationRequestCreateResponseSchema = import_zod2.z.object({
 }).passthrough();
 var skillVerificationStatusResponseSchema = import_zod2.z.object({
   name: import_zod2.z.string(),
+  version: import_zod2.z.string(),
+  status: skillVerificationStatusLabelSchema,
   verified: import_zod2.z.boolean(),
   previouslyVerified: import_zod2.z.boolean(),
+  signals: skillVerificationSignalsSchema.nullable().optional(),
+  reviewNotes: import_zod2.z.string().nullable().optional(),
   pendingRequest: skillVerificationRequestSchema.nullable().optional()
 }).passthrough();
+var skillVerificationDomainProofChallengeRequestSchema = import_zod2.z.object({
+  name: import_zod2.z.string().min(1),
+  version: import_zod2.z.string().min(1).optional(),
+  domain: import_zod2.z.string().min(1).optional()
+}).passthrough();
+var skillVerificationDomainProofChallengeResponseSchema = import_zod2.z.object({
+  challengeId: import_zod2.z.string().min(1),
+  name: import_zod2.z.string().min(1),
+  version: import_zod2.z.string().min(1),
+  domain: import_zod2.z.string().min(1),
+  method: import_zod2.z.literal("dns_txt"),
+  txtRecordName: import_zod2.z.string().min(1),
+  txtRecordValue: import_zod2.z.string().min(1),
+  expiresAt: import_zod2.z.string().min(1)
+}).passthrough();
+var skillVerificationDomainProofVerifyRequestSchema = import_zod2.z.object({
+  name: import_zod2.z.string().min(1),
+  version: import_zod2.z.string().min(1).optional(),
+  domain: import_zod2.z.string().min(1).optional(),
+  challengeToken: import_zod2.z.string().min(1)
+}).passthrough();
+var skillVerificationDomainProofVerifyResponseSchema = import_zod2.z.object({
+  name: import_zod2.z.string().min(1),
+  version: import_zod2.z.string().min(1),
+  signal: skillVerificationDomainProofSignalSchema
+}).passthrough();
 
 // ../../src/utils/is-browser.ts
 var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
@@ -3560,6 +3788,40 @@ async function verifySenderOwnership(client, uaid) {
     "verification sender response"
   );
 }
+async function verifyUaidDnsTxt(client, payload) {
+  const raw = await client.requestJson("/verification/dns/verify", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: {
+      uaid: payload.uaid,
+      ...payload.persist !== void 0 ? { persist: payload.persist } : {}
+    }
+  });
+  return client.parseWithSchema(
+    raw,
+    verificationDnsStatusResponseSchema,
+    "verification dns verify response"
+  );
+}
+async function getVerificationDnsStatus(client, uaid, query) {
+  const params = new URLSearchParams();
+  if (query?.refresh !== void 0) {
+    params.set("refresh", String(query.refresh));
+  }
+  if (query?.persist !== void 0) {
+    params.set("persist", String(query.persist));
+  }
+  const queryString = params.toString();
+  const path2 = `/verification/dns/status/${encodeURIComponent(uaid)}${queryString ? `?${queryString}` : ""}`;
+  const raw = await client.requestJson(path2, {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    verificationDnsStatusResponseSchema,
+    "verification dns status response"
+  );
+}
 async function getRegisterStatus(client, uaid) {
   const raw = await client.requestJson(
     `/register/status/${encodeURIComponent(uaid)}`,
@@ -3624,6 +3886,24 @@ async function listSkills(client, params = {}) {
   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"
@@ -3634,6 +3914,62 @@ async function listSkills(client, params = {}) {
     "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 (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) {
@@ -3753,6 +4089,169 @@ async function getSkillOwnership(client, params) {
     "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 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 response.text();
+}
+async function resolveSkillManifest(client, skillRef) {
+  const normalizedSkillRef = skillRef.trim();
+  if (!normalizedSkillRef) {
+    throw new Error("skillRef is required");
+  }
+  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 = params.name.trim();
   if (!normalizedName) {
@@ -3795,7 +4294,11 @@ async function requestSkillVerification(client, payload) {
     "/skills/verification/request",
     {
       method: "POST",
-      body: { name: normalizedName, tier: payload.tier },
+      body: {
+        name: normalizedName,
+        version: payload.version,
+        tier: payload.tier
+      },
       headers: { "content-type": "application/json" }
     }
   );
@@ -3812,6 +4315,9 @@ async function getSkillVerificationStatus(client, params) {
   }
   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" }
@@ -3822,6 +4328,57 @@ async function getSkillVerificationStatus(client, params) {
     "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"
+  );
+}
 
 // ../../src/services/registry-broker/client/base-client.ts
 var import_buffer4 = require("buffer");
@@ -4165,6 +4722,12 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async listSkills(options) {
     return listSkills(this, options);
   }
+  async getSkillSecurityBreakdown(params) {
+    return getSkillSecurityBreakdown(this, params);
+  }
+  async getSkillsCatalog(options) {
+    return getSkillsCatalog(this, options);
+  }
   async listSkillVersions(params) {
     return listSkillVersions(this, params);
   }
@@ -4186,6 +4749,33 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async getSkillOwnership(params) {
     return getSkillOwnership(this, params);
   }
+  async getRecommendedSkillVersion(params) {
+    return getRecommendedSkillVersion(this, params);
+  }
+  async setRecommendedSkillVersion(payload) {
+    return setRecommendedSkillVersion(this, payload);
+  }
+  async getSkillDeprecations(params) {
+    return getSkillDeprecations(this, params);
+  }
+  async setSkillDeprecation(payload) {
+    return setSkillDeprecation(this, payload);
+  }
+  async getSkillBadge(params) {
+    return getSkillBadge(this, params);
+  }
+  async listSkillTags() {
+    return listSkillTags(this);
+  }
+  async listSkillCategories() {
+    return listSkillCategories(this);
+  }
+  async resolveSkillMarkdown(skillRef) {
+    return resolveSkillMarkdown(this, skillRef);
+  }
+  async resolveSkillManifest(skillRef) {
+    return resolveSkillManifest(this, skillRef);
+  }
   async getSkillVoteStatus(params) {
     return getSkillVoteStatus(this, params);
   }
@@ -4198,6 +4788,12 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async getSkillVerificationStatus(params) {
     return getSkillVerificationStatus(this, params);
   }
+  async createSkillDomainProofChallenge(payload) {
+    return createSkillDomainProofChallenge(this, payload);
+  }
+  async verifySkillDomainProof(payload) {
+    return verifySkillDomainProof(this, payload);
+  }
   async adaptersDetailed() {
     return adaptersDetailed(this);
   }
@@ -4393,6 +4989,12 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async verifySenderOwnership(uaid) {
     return verifySenderOwnership(this, uaid);
   }
+  async verifyUaidDnsTxt(payload) {
+    return verifyUaidDnsTxt(this, payload);
+  }
+  async getVerificationDnsStatus(uaid, query) {
+    return getVerificationDnsStatus(this, uaid, query);
+  }
   async fetchHistorySnapshot(sessionId, options) {
     return fetchHistorySnapshot(
       this.conversationContexts,