@hol-org/rb-client 0.1.177 → 0.1.179

package/dist/index.cjs

@@ -946,6 +946,339 @@ var creditPurchaseResponseSchema = import_zod2.z.object({
   transactionId: import_zod2.z.string(),
   consensusTimestamp: import_zod2.z.string().nullable().optional()
 });
+var creditProviderSummarySchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  publishableKey: import_zod2.z.string().optional(),
+  currency: import_zod2.z.string().optional(),
+  centsPerHbar: import_zod2.z.number().nullable().optional()
+});
+var creditProvidersResponseSchema = import_zod2.z.object({
+  providers: import_zod2.z.array(creditProviderSummarySchema)
+});
+var creditBalanceResponseSchema = import_zod2.z.object({
+  accountId: import_zod2.z.string(),
+  balance: import_zod2.z.number(),
+  balanceRecord: jsonValueSchema.optional(),
+  timestamp: import_zod2.z.string().optional()
+});
+var guardPlanIdSchema = import_zod2.z.enum(["free", "pro", "team", "enterprise"]);
+var guardBucketBalanceSchema = import_zod2.z.object({
+  bucketId: import_zod2.z.enum([
+    "registry_credits",
+    "chat_credits",
+    "guard_credits",
+    "org_policy_credits"
+  ]),
+  label: import_zod2.z.string(),
+  availableCredits: import_zod2.z.number(),
+  includedMonthlyCredits: import_zod2.z.number().nullable().optional()
+});
+var guardPrincipalSchema = import_zod2.z.object({
+  signedIn: import_zod2.z.boolean(),
+  userId: import_zod2.z.string().optional(),
+  email: import_zod2.z.string().optional(),
+  accountId: import_zod2.z.string().optional(),
+  stripeCustomerId: import_zod2.z.string().optional(),
+  roles: import_zod2.z.array(import_zod2.z.string())
+});
+var guardEntitlementsSchema = import_zod2.z.object({
+  planId: guardPlanIdSchema,
+  includedMonthlyCredits: import_zod2.z.number(),
+  deviceLimit: import_zod2.z.number(),
+  retentionDays: import_zod2.z.number(),
+  syncEnabled: import_zod2.z.boolean(),
+  premiumFeedsEnabled: import_zod2.z.boolean(),
+  teamPolicyEnabled: import_zod2.z.boolean()
+});
+var guardSessionResponseSchema = import_zod2.z.object({
+  principal: guardPrincipalSchema,
+  entitlements: guardEntitlementsSchema,
+  balance: import_zod2.z.object({
+    accountId: import_zod2.z.string(),
+    availableCredits: import_zod2.z.number()
+  }).nullable(),
+  bucketingMode: import_zod2.z.enum(["shared-ledger", "product-bucketed"]),
+  buckets: import_zod2.z.array(guardBucketBalanceSchema)
+});
+var guardBalanceResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  bucketingMode: import_zod2.z.enum(["shared-ledger", "product-bucketed"]),
+  buckets: import_zod2.z.array(guardBucketBalanceSchema)
+});
+var guardTrustMatchSchema = import_zod2.z.object({
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  artifactSlug: import_zod2.z.string(),
+  recommendation: import_zod2.z.enum(["monitor", "review", "block"]),
+  verified: import_zod2.z.boolean(),
+  safetyScore: import_zod2.z.number().nullable().optional(),
+  trustScore: import_zod2.z.number().nullable().optional(),
+  href: import_zod2.z.string().optional(),
+  ecosystem: import_zod2.z.string().optional()
+});
+var guardTrustByHashResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  query: import_zod2.z.object({
+    sha256: import_zod2.z.string()
+  }),
+  match: guardTrustMatchSchema.nullable(),
+  evidence: import_zod2.z.array(import_zod2.z.string())
+});
+var guardTrustResolveResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  query: import_zod2.z.object({
+    ecosystem: import_zod2.z.string().optional(),
+    name: import_zod2.z.string().optional(),
+    version: import_zod2.z.string().optional()
+  }),
+  items: import_zod2.z.array(guardTrustMatchSchema)
+});
+var guardRevocationSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  reason: import_zod2.z.string(),
+  severity: import_zod2.z.enum(["low", "medium", "high"]),
+  publishedAt: import_zod2.z.string()
+});
+var guardRevocationResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  items: import_zod2.z.array(guardRevocationSchema)
+});
+var guardReceiptSchema = import_zod2.z.object({
+  receiptId: import_zod2.z.string(),
+  capturedAt: import_zod2.z.string(),
+  harness: import_zod2.z.string(),
+  deviceId: import_zod2.z.string(),
+  deviceName: import_zod2.z.string(),
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  artifactSlug: import_zod2.z.string(),
+  artifactHash: import_zod2.z.string(),
+  policyDecision: import_zod2.z.enum([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  recommendation: import_zod2.z.enum(["monitor", "review", "block"]),
+  changedSinceLastApproval: import_zod2.z.boolean(),
+  publisher: import_zod2.z.string().optional(),
+  capabilities: import_zod2.z.array(import_zod2.z.string()),
+  summary: import_zod2.z.string()
+});
+var guardHistoryArtifactSchema = import_zod2.z.object({
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  artifactSlug: import_zod2.z.string(),
+  publisher: import_zod2.z.string().optional(),
+  harnesses: import_zod2.z.array(import_zod2.z.string()),
+  eventCount: import_zod2.z.number(),
+  firstSeenAt: import_zod2.z.string(),
+  lastSeenAt: import_zod2.z.string(),
+  latestDecision: import_zod2.z.enum([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  latestRecommendation: import_zod2.z.enum(["monitor", "review", "block"])
+});
+var guardReceiptHistoryResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  artifacts: import_zod2.z.array(guardHistoryArtifactSchema)
+});
+var guardInventoryArtifactSchema = import_zod2.z.object({
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  artifactSlug: import_zod2.z.string(),
+  publisher: import_zod2.z.string().optional(),
+  harnesses: import_zod2.z.array(import_zod2.z.string()),
+  devices: import_zod2.z.array(import_zod2.z.string()),
+  eventCount: import_zod2.z.number(),
+  firstSeenAt: import_zod2.z.string(),
+  lastSeenAt: import_zod2.z.string(),
+  latestDecision: import_zod2.z.enum([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  latestRecommendation: import_zod2.z.enum(["monitor", "review", "block"]),
+  latestHash: import_zod2.z.string(),
+  latestSummary: import_zod2.z.string()
+});
+var guardInventoryDiffEntrySchema = import_zod2.z.object({
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  changeType: import_zod2.z.enum(["new", "changed", "removed"]),
+  previousHash: import_zod2.z.string().nullable(),
+  currentHash: import_zod2.z.string().nullable()
+});
+var guardInventoryDiffResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  items: import_zod2.z.array(guardInventoryDiffEntrySchema)
+});
+var guardReceiptSyncResponseSchema = import_zod2.z.object({
+  syncedAt: import_zod2.z.string(),
+  receiptsStored: import_zod2.z.number(),
+  inventoryStored: import_zod2.z.number().optional(),
+  inventoryDiff: guardInventoryDiffResponseSchema.optional()
+});
+var guardInventoryResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  items: import_zod2.z.array(guardInventoryArtifactSchema)
+});
+var guardAbomSummarySchema = import_zod2.z.object({
+  totalArtifacts: import_zod2.z.number(),
+  totalDevices: import_zod2.z.number(),
+  totalHarnesses: import_zod2.z.number(),
+  blockedArtifacts: import_zod2.z.number(),
+  reviewArtifacts: import_zod2.z.number()
+});
+var guardAbomResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  summary: guardAbomSummarySchema,
+  items: import_zod2.z.array(guardInventoryArtifactSchema)
+});
+var guardTimelineEventSchema = import_zod2.z.object({
+  receiptId: import_zod2.z.string(),
+  capturedAt: import_zod2.z.string(),
+  harness: import_zod2.z.string(),
+  deviceId: import_zod2.z.string(),
+  deviceName: import_zod2.z.string(),
+  artifactHash: import_zod2.z.string(),
+  policyDecision: import_zod2.z.enum([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  recommendation: import_zod2.z.enum(["monitor", "review", "block"]),
+  changedSinceLastApproval: import_zod2.z.boolean(),
+  summary: import_zod2.z.string(),
+  capabilities: import_zod2.z.array(import_zod2.z.string()),
+  publisher: import_zod2.z.string().optional()
+});
+var guardArtifactTimelineResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  artifactSlug: import_zod2.z.string(),
+  events: import_zod2.z.array(guardTimelineEventSchema)
+});
+var guardReceiptExportSummarySchema = import_zod2.z.object({
+  totalReceipts: import_zod2.z.number(),
+  blockedCount: import_zod2.z.number(),
+  reviewCount: import_zod2.z.number(),
+  approvedCount: import_zod2.z.number()
+});
+var guardExportSignatureSchema = import_zod2.z.object({
+  algorithm: import_zod2.z.enum(["hmac-sha256", "none"]),
+  digest: import_zod2.z.string()
+});
+var guardReceiptExportResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  summary: guardReceiptExportSummarySchema,
+  provenanceSummary: import_zod2.z.array(import_zod2.z.string()),
+  items: import_zod2.z.array(guardReceiptSchema),
+  signature: guardExportSignatureSchema
+});
+var guardAlertPreferencesSchema = import_zod2.z.object({
+  emailEnabled: import_zod2.z.boolean(),
+  digestMode: import_zod2.z.enum(["immediate", "daily", "weekly"]),
+  watchlistEnabled: import_zod2.z.boolean(),
+  advisoriesEnabled: import_zod2.z.boolean(),
+  repeatedWarningsEnabled: import_zod2.z.boolean(),
+  teamAlertsEnabled: import_zod2.z.boolean(),
+  updatedAt: import_zod2.z.string()
+});
+var guardWatchlistItemSchema = import_zod2.z.object({
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  artifactSlug: import_zod2.z.string(),
+  reason: import_zod2.z.string(),
+  source: import_zod2.z.enum(["manual", "synced", "team-policy"]),
+  createdAt: import_zod2.z.string()
+});
+var guardWatchlistResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  items: import_zod2.z.array(guardWatchlistItemSchema)
+});
+var guardExceptionItemSchema = import_zod2.z.object({
+  exceptionId: import_zod2.z.string(),
+  scope: import_zod2.z.enum(["artifact", "publisher", "harness", "global"]),
+  harness: import_zod2.z.string().nullable(),
+  artifactId: import_zod2.z.string().nullable(),
+  publisher: import_zod2.z.string().nullable(),
+  reason: import_zod2.z.string(),
+  owner: import_zod2.z.string(),
+  source: import_zod2.z.enum(["manual", "team-policy"]),
+  expiresAt: import_zod2.z.string(),
+  createdAt: import_zod2.z.string(),
+  updatedAt: import_zod2.z.string()
+});
+var guardExceptionListResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  items: import_zod2.z.array(guardExceptionItemSchema)
+});
+var guardTeamPolicyAuditItemSchema = import_zod2.z.object({
+  changedAt: import_zod2.z.string(),
+  actor: import_zod2.z.string(),
+  change: import_zod2.z.enum(["created", "updated"]),
+  summary: import_zod2.z.string()
+});
+var guardTeamPolicyPackSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  sharedHarnessDefaults: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.enum(["observe", "prompt", "enforce"])),
+  allowedPublishers: import_zod2.z.array(import_zod2.z.string()),
+  blockedArtifacts: import_zod2.z.array(import_zod2.z.string()),
+  alertChannel: import_zod2.z.enum(["email", "slack", "teams", "webhook"]),
+  updatedAt: import_zod2.z.string(),
+  auditTrail: import_zod2.z.array(guardTeamPolicyAuditItemSchema)
+});
+var guardDeviceSchema = import_zod2.z.object({
+  deviceId: import_zod2.z.string(),
+  deviceName: import_zod2.z.string(),
+  harnesses: import_zod2.z.array(import_zod2.z.string()),
+  receiptCount: import_zod2.z.number(),
+  lastSeenAt: import_zod2.z.string()
+});
+var guardDeviceListResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  items: import_zod2.z.array(guardDeviceSchema)
+});
+var hbarPurchaseIntentResponseSchema = import_zod2.z.object({
+  transaction: import_zod2.z.string(),
+  transactionId: import_zod2.z.string(),
+  network: import_zod2.z.enum(["mainnet", "testnet"]),
+  accountId: import_zod2.z.string(),
+  treasuryAccountId: import_zod2.z.string(),
+  hbarAmount: import_zod2.z.number(),
+  credits: import_zod2.z.number(),
+  tinybarAmount: import_zod2.z.number(),
+  memo: import_zod2.z.string(),
+  centsPerHbar: import_zod2.z.number(),
+  validStart: import_zod2.z.string(),
+  validDurationSeconds: import_zod2.z.number(),
+  requiresManualSubmit: import_zod2.z.literal(true),
+  purchaseId: import_zod2.z.string()
+});
 var x402SettlementSchema = import_zod2.z.object({
   success: import_zod2.z.boolean().optional(),
   transaction: import_zod2.z.string().optional(),
@@ -1328,11 +1661,13 @@ var skillDeprecationsResponseSchema = import_zod2.z.object({
   name: import_zod2.z.string(),
   items: import_zod2.z.array(skillDeprecationRecordSchema)
 }).passthrough();
+var skillSecurityBreakdownFindingSchema = import_zod2.z.record(jsonValueSchema);
+var skillSecurityBreakdownSummarySchema = import_zod2.z.record(jsonValueSchema);
 var skillSecurityBreakdownResponseSchema = import_zod2.z.object({
   jobId: import_zod2.z.string(),
   score: import_zod2.z.number().nullable().optional(),
-  findings: import_zod2.z.array(import_zod2.z.unknown()).optional(),
-  summary: import_zod2.z.unknown().optional(),
+  findings: import_zod2.z.array(skillSecurityBreakdownFindingSchema).optional(),
+  summary: skillSecurityBreakdownSummarySchema.optional(),
   generatedAt: import_zod2.z.string().nullable().optional(),
   scannerVersion: import_zod2.z.string().nullable().optional()
 }).passthrough();
@@ -2797,9 +3132,16 @@ var isBrowser = typeof window !== "undefined" && typeof window.document !== "und
 var import_meta = {};
 var nodeRequire;
 var isNodeRuntime = () => typeof process !== "undefined" && Boolean(process.versions?.node);
+function resolveBuiltinModuleLoader() {
+  if (typeof process === "undefined") {
+    return void 0;
+  }
+  return process.getBuiltinModule;
+}
 function getNodeRequireSync() {
   try {
-    const moduleNamespace = process.getBuiltinModule?.("module");
+    const builtinModuleLoader = resolveBuiltinModuleLoader();
+    const moduleNamespace = builtinModuleLoader?.("module");
     if (typeof moduleNamespace?.createRequire === "function") {
       const requireFromModule = moduleNamespace.createRequire(import_meta.url);
       if (typeof requireFromModule.resolve === "function") {
@@ -3199,6 +3541,61 @@ async function adapterRegistrySubmissionStatus(client, submissionId) {
 }
 
 // ../../src/services/registry-broker/client/credits.ts
+async function getCreditsBalance(client, params = {}) {
+  const query = new URLSearchParams();
+  const normalizedAccountId = params.accountId?.trim();
+  if (normalizedAccountId) {
+    query.set("accountId", normalizedAccountId);
+  }
+  const suffix = query.size > 0 ? `?${query.toString()}` : "";
+  const raw = await client.requestJson(`/credits/balance${suffix}`, {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    creditBalanceResponseSchema,
+    "credit balance response"
+  );
+}
+async function getCreditProviders(client) {
+  const raw = await client.requestJson("/credits/providers", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    creditProvidersResponseSchema,
+    "credit providers response"
+  );
+}
+async function createHbarPurchaseIntent(client, payload) {
+  const body = {};
+  const normalizedAccountId = payload.accountId?.trim();
+  if (normalizedAccountId) {
+    body.accountId = normalizedAccountId;
+  }
+  if (payload.credits !== void 0) {
+    body.credits = payload.credits;
+  }
+  if (payload.hbarAmount !== void 0) {
+    body.hbarAmount = payload.hbarAmount;
+  }
+  if (payload.memo?.trim()) {
+    body.memo = payload.memo.trim();
+  }
+  const raw = await client.requestJson(
+    "/credits/payments/hbar/intent",
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    hbarPurchaseIntentResponseSchema,
+    "hbar purchase intent response"
+  );
+}
 async function loadX402Dependencies(client) {
   const [{ default: axios }, x402Axios, x402Types] = await Promise.all([
     import("axios"),
@@ -3726,6 +4123,285 @@ async function registerOwnedMoltbookAgent(client, uaid, request) {
   );
 }
 
+// ../../src/services/registry-broker/client/guard.ts
+async function getGuardSession(client) {
+  const raw = await client.requestJson("/guard/auth/session", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardSessionResponseSchema,
+    "guard session response"
+  );
+}
+async function getGuardEntitlements(client) {
+  const raw = await client.requestJson("/guard/entitlements", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardSessionResponseSchema,
+    "guard entitlements response"
+  );
+}
+async function getGuardBillingBalance(client) {
+  const raw = await client.requestJson("/guard/billing/balance", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardBalanceResponseSchema,
+    "guard billing balance response"
+  );
+}
+async function getGuardTrustByHash(client, sha256) {
+  const normalizedHash = sha256.trim();
+  if (!normalizedHash) {
+    throw new Error("sha256 is required");
+  }
+  const raw = await client.requestJson(
+    `/guard/trust/by-hash/${encodeURIComponent(normalizedHash)}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    guardTrustByHashResponseSchema,
+    "guard trust by hash response"
+  );
+}
+async function resolveGuardTrust(client, query) {
+  const params = new URLSearchParams();
+  if (query.ecosystem?.trim()) {
+    params.set("ecosystem", query.ecosystem.trim());
+  }
+  if (query.name?.trim()) {
+    params.set("name", query.name.trim());
+  }
+  if (query.version?.trim()) {
+    params.set("version", query.version.trim());
+  }
+  const suffix = params.size > 0 ? `?${params.toString()}` : "";
+  const raw = await client.requestJson(
+    `/guard/trust/resolve${suffix}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    guardTrustResolveResponseSchema,
+    "guard trust resolve response"
+  );
+}
+async function getGuardRevocations(client) {
+  const raw = await client.requestJson("/guard/revocations", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardRevocationResponseSchema,
+    "guard revocations response"
+  );
+}
+async function getGuardInventory(client) {
+  const raw = await client.requestJson("/guard/inventory", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardInventoryResponseSchema,
+    "guard inventory response"
+  );
+}
+async function getGuardReceiptHistory(client) {
+  const raw = await client.requestJson("/guard/history", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardReceiptHistoryResponseSchema,
+    "guard receipt history response"
+  );
+}
+async function getGuardArtifactTimeline(client, artifactId) {
+  const normalizedArtifactId = artifactId.trim();
+  if (!normalizedArtifactId) {
+    throw new Error("artifactId is required");
+  }
+  const raw = await client.requestJson(
+    `/guard/history/${encodeURIComponent(normalizedArtifactId)}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    guardArtifactTimelineResponseSchema,
+    "guard artifact timeline response"
+  );
+}
+async function exportGuardAbom(client) {
+  const raw = await client.requestJson("/guard/abom", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardAbomResponseSchema,
+    "guard abom response"
+  );
+}
+async function exportGuardReceipts(client) {
+  const raw = await client.requestJson("/guard/receipts/export", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardReceiptExportResponseSchema,
+    "guard receipt export response"
+  );
+}
+async function getGuardInventoryDiff(client) {
+  const raw = await client.requestJson("/guard/inventory/diff", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardInventoryDiffResponseSchema,
+    "guard inventory diff response"
+  );
+}
+async function getGuardDevices(client) {
+  const raw = await client.requestJson("/guard/devices", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardDeviceListResponseSchema,
+    "guard devices response"
+  );
+}
+async function getGuardAlertPreferences(client) {
+  const raw = await client.requestJson("/guard/alerts/preferences", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardAlertPreferencesSchema,
+    "guard alert preferences response"
+  );
+}
+async function updateGuardAlertPreferences(client, payload) {
+  const raw = await client.requestJson("/guard/alerts/preferences", {
+    method: "PUT",
+    body: payload
+  });
+  return client.parseWithSchema(
+    raw,
+    guardAlertPreferencesSchema,
+    "guard alert preferences response"
+  );
+}
+async function getGuardExceptions(client) {
+  const raw = await client.requestJson("/guard/exceptions", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardExceptionListResponseSchema,
+    "guard exceptions response"
+  );
+}
+async function getGuardWatchlist(client) {
+  const raw = await client.requestJson("/guard/watchlist", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardWatchlistResponseSchema,
+    "guard watchlist response"
+  );
+}
+async function addGuardWatchlistItem(client, payload) {
+  const raw = await client.requestJson("/guard/watchlist", {
+    method: "POST",
+    body: payload
+  });
+  return client.parseWithSchema(
+    raw,
+    guardWatchlistResponseSchema,
+    "guard watchlist response"
+  );
+}
+async function removeGuardWatchlistItem(client, artifactId) {
+  const normalizedArtifactId = artifactId.trim();
+  if (!normalizedArtifactId) {
+    throw new Error("artifactId is required");
+  }
+  const raw = await client.requestJson(
+    `/guard/watchlist/${encodeURIComponent(normalizedArtifactId)}`,
+    { method: "DELETE" }
+  );
+  return client.parseWithSchema(
+    raw,
+    guardWatchlistResponseSchema,
+    "guard watchlist response"
+  );
+}
+async function addGuardException(client, payload) {
+  const raw = await client.requestJson("/guard/exceptions", {
+    method: "POST",
+    body: payload
+  });
+  return client.parseWithSchema(
+    raw,
+    guardExceptionListResponseSchema,
+    "guard exceptions response"
+  );
+}
+async function removeGuardException(client, exceptionId) {
+  const normalizedExceptionId = exceptionId.trim();
+  if (!normalizedExceptionId) {
+    throw new Error("exceptionId is required");
+  }
+  const raw = await client.requestJson(
+    `/guard/exceptions/${encodeURIComponent(normalizedExceptionId)}`,
+    { method: "DELETE" }
+  );
+  return client.parseWithSchema(
+    raw,
+    guardExceptionListResponseSchema,
+    "guard exceptions response"
+  );
+}
+async function getGuardTeamPolicyPack(client) {
+  const raw = await client.requestJson("/guard/team/policy-pack", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardTeamPolicyPackSchema,
+    "guard team policy pack response"
+  );
+}
+async function updateGuardTeamPolicyPack(client, payload) {
+  const raw = await client.requestJson("/guard/team/policy-pack", {
+    method: "PUT",
+    body: payload
+  });
+  return client.parseWithSchema(
+    raw,
+    guardTeamPolicyPackSchema,
+    "guard team policy pack response"
+  );
+}
+async function syncGuardReceipts(client, payload) {
+  const raw = await client.requestJson("/guard/receipts/sync", {
+    method: "POST",
+    body: payload
+  });
+  return client.parseWithSchema(
+    raw,
+    guardReceiptSyncResponseSchema,
+    "guard receipt sync response"
+  );
+}
+
 // ../../src/services/registry-broker/client/ledger-auth.ts
 var import_buffer3 = require("buffer");
 
@@ -4297,6 +4973,13 @@ async function facets(client, adapter) {
 }
 
 // ../../src/services/registry-broker/client/skills.ts
+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"
@@ -4356,10 +5039,7 @@ async function listSkills(client, params = {}) {
   );
 }
 async function getSkillSecurityBreakdown(client, params) {
-  const normalizedJobId = params.jobId.trim();
-  if (!normalizedJobId) {
-    throw new Error("jobId is required");
-  }
+  const normalizedJobId = requireTrimmedString(params.jobId, "jobId");
   const raw = await client.requestJson(
     `/skills/${encodeURIComponent(normalizedJobId)}/security-breakdown`,
     { method: "GET" }
@@ -4412,10 +5092,7 @@ async function getSkillsCatalog(client, params = {}) {
   );
 }
 async function listSkillVersions(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   const raw = await client.requestJson(
@@ -4501,10 +5178,7 @@ async function publishSkill(client, payload) {
   );
 }
 async function getSkillPublishJob(client, jobId, params = {}) {
-  const normalized = jobId.trim();
-  if (!normalized) {
-    throw new Error("jobId is required");
-  }
+  const normalized = requireTrimmedString(jobId, "jobId");
   const query = new URLSearchParams();
   if (params.accountId) {
     query.set("accountId", params.accountId);
@@ -4521,10 +5195,7 @@ async function getSkillPublishJob(client, jobId, params = {}) {
   );
 }
 async function getSkillOwnership(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   if (params.accountId) {
@@ -4543,10 +5214,7 @@ async function getSkillOwnership(client, params) {
   );
 }
 async function getRecommendedSkillVersion(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   const raw = await client.requestJson(
@@ -4560,14 +5228,8 @@ async function getRecommendedSkillVersion(client, params) {
   );
 }
 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 normalizedName = requireTrimmedString(payload.name, "name");
+  const normalizedVersion = requireTrimmedString(payload.version, "version");
   const raw = await client.requestJson("/skills/recommended", {
     method: "POST",
     body: {
@@ -4583,10 +5245,7 @@ async function setRecommendedSkillVersion(client, payload) {
   );
 }
 async function getSkillDeprecations(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   const raw = await client.requestJson(
@@ -4600,15 +5259,9 @@ async function getSkillDeprecations(client, params) {
   );
 }
 async function setSkillDeprecation(client, payload) {
-  const normalizedName = payload.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(payload.name, "name");
   const version = payload.version?.trim();
-  const reason = payload.reason.trim();
-  if (!reason) {
-    throw new Error("reason is required");
-  }
+  const reason = requireTrimmedString(payload.reason, "reason");
   const replacementRef = payload.replacementRef?.trim();
   const raw = await client.requestJson("/skills/deprecate", {
     method: "POST",
@@ -4627,10 +5280,7 @@ async function setSkillDeprecation(client, payload) {
   );
 }
 async function getSkillBadge(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   if (params.metric) {
@@ -4653,10 +5303,7 @@ async function getSkillBadge(client, params) {
   );
 }
 async function getSkillStatus(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   if (params.version?.trim()) {
@@ -4673,14 +5320,8 @@ async function getSkillStatus(client, params) {
   );
 }
 async function getSkillStatusByRepo(client, 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 repo = requireTrimmedString(params.repo, "repo");
+  const skillDir = requireTrimmedString(params.skillDir, "skillDir");
   const query = new URLSearchParams();
   query.set("repo", repo);
   query.set("skillDir", skillDir);
@@ -4698,14 +5339,8 @@ async function getSkillStatusByRepo(client, params) {
   );
 }
 async function getSkillConversionSignalsByRepo(client, 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 repo = requireTrimmedString(params.repo, "repo");
+  const skillDir = requireTrimmedString(params.skillDir, "skillDir");
   const query = new URLSearchParams();
   query.set("repo", repo);
   query.set("skillDir", skillDir);
@@ -4723,10 +5358,7 @@ async function getSkillConversionSignalsByRepo(client, params) {
   );
 }
 async function uploadSkillPreviewFromGithubOidc(client, payload) {
-  const token = payload.token.trim();
-  if (!token) {
-    throw new Error("token is required");
-  }
+  const token = requireTrimmedString(payload.token, "token");
   const raw = await client.requestJson(
     "/skills/preview/github-oidc",
     {
@@ -4745,10 +5377,7 @@ async function uploadSkillPreviewFromGithubOidc(client, payload) {
   );
 }
 async function getSkillPreview(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   if (params.version?.trim()) {
@@ -4765,14 +5394,8 @@ async function getSkillPreview(client, params) {
   );
 }
 async function getSkillPreviewByRepo(client, 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 repo = requireTrimmedString(params.repo, "repo");
+  const skillDir = requireTrimmedString(params.skillDir, "skillDir");
   const query = new URLSearchParams();
   query.set("repo", repo);
   query.set("skillDir", skillDir);
@@ -4790,10 +5413,7 @@ async function getSkillPreviewByRepo(client, params) {
   );
 }
 async function getSkillPreviewById(client, previewId) {
-  const normalizedPreviewId = previewId.trim();
-  if (!normalizedPreviewId) {
-    throw new Error("previewId is required");
-  }
+  const normalizedPreviewId = requireTrimmedString(previewId, "previewId");
   const raw = await client.requestJson(
     `/skills/preview/${encodeURIComponent(normalizedPreviewId)}`,
     { method: "GET" }
@@ -4805,10 +5425,7 @@ async function getSkillPreviewById(client, previewId) {
   );
 }
 async function getSkillInstall(client, skillRef) {
-  const normalizedSkillRef = skillRef.trim();
-  if (!normalizedSkillRef) {
-    throw new Error("skillRef is required");
-  }
+  const normalizedSkillRef = requireTrimmedString(skillRef, "skillRef");
   const raw = await client.requestJson(
     `/skills/${encodeURIComponent(normalizedSkillRef)}/install`,
     { method: "GET" }
@@ -4820,10 +5437,7 @@ async function getSkillInstall(client, skillRef) {
   );
 }
 async function recordSkillInstallCopy(client, skillRef, payload = {}) {
-  const normalizedSkillRef = skillRef.trim();
-  if (!normalizedSkillRef) {
-    throw new Error("skillRef is required");
-  }
+  const normalizedSkillRef = requireTrimmedString(skillRef, "skillRef");
   const raw = await client.requestJson(
     `/skills/${encodeURIComponent(normalizedSkillRef)}/telemetry/install-copy`,
     {
@@ -4859,10 +5473,7 @@ async function listSkillCategories(client) {
   );
 }
 async function resolveSkillMarkdown(client, skillRef) {
-  const normalizedSkillRef = skillRef.trim();
-  if (!normalizedSkillRef) {
-    throw new Error("skillRef is required");
-  }
+  const normalizedSkillRef = requireTrimmedString(skillRef, "skillRef");
   const response = await client.request(
     `/skills/${encodeURIComponent(normalizedSkillRef)}/SKILL.md`,
     {
@@ -4875,10 +5486,7 @@ async function resolveSkillMarkdown(client, skillRef) {
   return response.text();
 }
 async function resolveSkillManifest(client, skillRef) {
-  const normalizedSkillRef = skillRef.trim();
-  if (!normalizedSkillRef) {
-    throw new Error("skillRef is required");
-  }
+  const normalizedSkillRef = requireTrimmedString(skillRef, "skillRef");
   const raw = await client.requestJson(
     `/skills/${encodeURIComponent(normalizedSkillRef)}/manifest`,
     {
@@ -4892,10 +5500,7 @@ async function resolveSkillManifest(client, skillRef) {
   );
 }
 async function getSkillVoteStatus(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   const raw = await client.requestJson(
@@ -4909,10 +5514,7 @@ async function getSkillVoteStatus(client, params) {
   );
 }
 async function setSkillVote(client, payload) {
-  const normalizedName = payload.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(payload.name, "name");
   const raw = await client.requestJson("/skills/vote", {
     method: "POST",
     body: { name: normalizedName, upvoted: payload.upvoted },
@@ -4925,10 +5527,7 @@ async function setSkillVote(client, payload) {
   );
 }
 async function requestSkillVerification(client, payload) {
-  const normalizedName = payload.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(payload.name, "name");
   const raw = await client.requestJson(
     "/skills/verification/request",
     {
@@ -4948,10 +5547,7 @@ async function requestSkillVerification(client, payload) {
   );
 }
 async function getSkillVerificationStatus(client, params) {
-  const normalizedName = params.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(params.name, "name");
   const query = new URLSearchParams();
   query.set("name", normalizedName);
   if (params.version) {
@@ -4968,10 +5564,7 @@ async function getSkillVerificationStatus(client, params) {
   );
 }
 async function createSkillDomainProofChallenge(client, payload) {
-  const normalizedName = payload.name.trim();
-  if (!normalizedName) {
-    throw new Error("name is required");
-  }
+  const normalizedName = requireTrimmedString(payload.name, "name");
   const raw = await client.requestJson(
     "/skills/verification/domain/challenge",
     {
@@ -4991,14 +5584,11 @@ async function createSkillDomainProofChallenge(client, payload) {
   );
 }
 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 normalizedName = requireTrimmedString(payload.name, "name");
+  const challengeToken = requireTrimmedString(
+    payload.challengeToken,
+    "challengeToken"
+  );
   const raw = await client.requestJson(
     "/skills/verification/domain/verify",
     {
@@ -5612,6 +6202,87 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async dashboardStats() {
     return dashboardStats(this);
   }
+  async getCreditsBalance(params = {}) {
+    return getCreditsBalance(this, params);
+  }
+  async getCreditProviders() {
+    return getCreditProviders(this);
+  }
+  async getGuardSession() {
+    return getGuardSession(this);
+  }
+  async getGuardEntitlements() {
+    return getGuardEntitlements(this);
+  }
+  async getGuardBillingBalance() {
+    return getGuardBillingBalance(this);
+  }
+  async getGuardTrustByHash(sha256) {
+    return getGuardTrustByHash(this, sha256);
+  }
+  async resolveGuardTrust(query) {
+    return resolveGuardTrust(this, query);
+  }
+  async getGuardRevocations() {
+    return getGuardRevocations(this);
+  }
+  async getGuardInventory() {
+    return getGuardInventory(this);
+  }
+  async getGuardReceiptHistory() {
+    return getGuardReceiptHistory(this);
+  }
+  async getGuardArtifactTimeline(artifactId) {
+    return getGuardArtifactTimeline(this, artifactId);
+  }
+  async getGuardInventoryDiff() {
+    return getGuardInventoryDiff(this);
+  }
+  async exportGuardAbom() {
+    return exportGuardAbom(this);
+  }
+  async exportGuardReceipts() {
+    return exportGuardReceipts(this);
+  }
+  async getGuardDevices() {
+    return getGuardDevices(this);
+  }
+  async getGuardAlertPreferences() {
+    return getGuardAlertPreferences(this);
+  }
+  async updateGuardAlertPreferences(payload) {
+    return updateGuardAlertPreferences(this, payload);
+  }
+  async getGuardExceptions() {
+    return getGuardExceptions(this);
+  }
+  async getGuardWatchlist() {
+    return getGuardWatchlist(this);
+  }
+  async addGuardWatchlistItem(payload) {
+    return addGuardWatchlistItem(this, payload);
+  }
+  async removeGuardWatchlistItem(artifactId) {
+    return removeGuardWatchlistItem(this, artifactId);
+  }
+  async addGuardException(payload) {
+    return addGuardException(this, payload);
+  }
+  async removeGuardException(exceptionId) {
+    return removeGuardException(this, exceptionId);
+  }
+  async syncGuardReceipts(payload) {
+    return syncGuardReceipts(this, payload);
+  }
+  async getGuardTeamPolicyPack() {
+    return getGuardTeamPolicyPack(this);
+  }
+  async updateGuardTeamPolicyPack(payload) {
+    return updateGuardTeamPolicyPack(this, payload);
+  }
+  async createHbarPurchaseIntent(payload) {
+    return createHbarPurchaseIntent(this, payload);
+  }
   async purchaseCreditsWithHbar(params) {
     return purchaseCreditsWithHbar(this, params);
   }