@hol-org/rb-client 0.1.178 → 0.1.180

package/dist/index.cjs

@@ -975,10 +975,14 @@ var guardBucketBalanceSchema = import_zod2.z.object({
 });
 var guardPrincipalSchema = import_zod2.z.object({
   signedIn: import_zod2.z.boolean(),
+  principalType: import_zod2.z.enum(["user", "service"]).default("user"),
   userId: import_zod2.z.string().optional(),
   email: import_zod2.z.string().optional(),
   accountId: import_zod2.z.string().optional(),
   stripeCustomerId: import_zod2.z.string().optional(),
+  serviceId: import_zod2.z.string().optional(),
+  workspaceId: import_zod2.z.string().optional(),
+  serviceLabel: import_zod2.z.string().optional(),
   roles: import_zod2.z.array(import_zod2.z.string())
 });
 var guardEntitlementsSchema = import_zod2.z.object({
@@ -1005,6 +1009,65 @@ var guardBalanceResponseSchema = import_zod2.z.object({
   bucketingMode: import_zod2.z.enum(["shared-ledger", "product-bucketed"]),
   buckets: import_zod2.z.array(guardBucketBalanceSchema)
 });
+var guardFeedItemSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  slug: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  href: import_zod2.z.string(),
+  ecosystem: import_zod2.z.string().optional(),
+  safetyScore: import_zod2.z.number().nullable().optional(),
+  trustScore: import_zod2.z.number().nullable().optional(),
+  verified: import_zod2.z.boolean(),
+  recommendation: import_zod2.z.enum(["monitor", "review", "block"]),
+  updatedAt: import_zod2.z.string()
+});
+var guardFeedSummarySchema = import_zod2.z.object({
+  total: import_zod2.z.number(),
+  monitorCount: import_zod2.z.number(),
+  reviewCount: import_zod2.z.number(),
+  blockCount: import_zod2.z.number()
+});
+var guardFeedResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  items: import_zod2.z.array(guardFeedItemSchema),
+  summary: guardFeedSummarySchema
+});
+var guardIntegrationSchema = import_zod2.z.object({
+  id: import_zod2.z.enum(["openclaw", "hermes"]),
+  name: import_zod2.z.string(),
+  status: import_zod2.z.enum(["available", "planned"]),
+  href: import_zod2.z.string().nullable(),
+  summary: import_zod2.z.string()
+});
+var guardActionItemSchema = import_zod2.z.object({
+  title: import_zod2.z.string(),
+  description: import_zod2.z.string(),
+  href: import_zod2.z.string()
+});
+var guardOverviewResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  principal: guardPrincipalSchema,
+  entitlements: guardEntitlementsSchema,
+  balance: import_zod2.z.object({
+    accountId: import_zod2.z.string(),
+    availableCredits: import_zod2.z.number()
+  }).nullable(),
+  trustFeed: guardFeedResponseSchema,
+  integrations: import_zod2.z.array(guardIntegrationSchema),
+  actionItems: import_zod2.z.array(guardActionItemSchema)
+});
+var guardPolicySchema = import_zod2.z.object({
+  mode: import_zod2.z.enum(["observe", "prompt", "enforce"]),
+  defaultAction: import_zod2.z.enum(["allow", "warn", "block"]),
+  unknownPublisherAction: import_zod2.z.enum(["review", "block", "allow"]),
+  changedHashAction: import_zod2.z.enum(["allow", "warn", "require-reapproval", "block"]),
+  newNetworkDomainAction: import_zod2.z.enum(["allow", "warn", "block"]),
+  subprocessAction: import_zod2.z.enum(["allow", "warn", "block"]),
+  telemetryEnabled: import_zod2.z.boolean(),
+  syncEnabled: import_zod2.z.boolean(),
+  updatedAt: import_zod2.z.string()
+});
 var guardTrustMatchSchema = import_zod2.z.object({
   artifactId: import_zod2.z.string(),
   artifactName: import_zod2.z.string(),
@@ -1040,7 +1103,13 @@ var guardRevocationSchema = import_zod2.z.object({
   artifactName: import_zod2.z.string(),
   reason: import_zod2.z.string(),
   severity: import_zod2.z.enum(["low", "medium", "high"]),
-  publishedAt: import_zod2.z.string()
+  publishedAt: import_zod2.z.string(),
+  confidence: import_zod2.z.number().optional(),
+  remediation: import_zod2.z.string().nullable().optional(),
+  scope: import_zod2.z.enum(["artifact", "publisher", "domain", "workspace", "ecosystem"]).optional(),
+  source: import_zod2.z.string().optional(),
+  firstSeenAt: import_zod2.z.string().optional(),
+  lastUpdatedAt: import_zod2.z.string().optional()
 });
 var guardRevocationResponseSchema = import_zod2.z.object({
   generatedAt: import_zod2.z.string(),
@@ -1071,9 +1140,299 @@ var guardReceiptSchema = import_zod2.z.object({
   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()
+  receiptsStored: import_zod2.z.number(),
+  inventoryStored: import_zod2.z.number().optional(),
+  inventoryDiff: guardInventoryDiffResponseSchema.optional(),
+  advisories: import_zod2.z.array(guardRevocationSchema).optional(),
+  policy: guardPolicySchema.optional(),
+  alertPreferences: import_zod2.z.lazy(() => guardAlertPreferencesSchema).optional(),
+  exceptions: import_zod2.z.array(import_zod2.z.lazy(() => guardExceptionItemSchema)).optional(),
+  teamPolicyPack: import_zod2.z.lazy(() => guardTeamPolicyPackSchema).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 guardWatchlistLookupMatchSchema = import_zod2.z.object({
+  artifactId: import_zod2.z.string().nullable(),
+  publisher: import_zod2.z.string().nullable(),
+  domain: import_zod2.z.string().nullable(),
+  source: import_zod2.z.enum(["watchlist", "team-policy"]),
+  reason: import_zod2.z.string()
+});
+var guardWatchlistLookupResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  matched: import_zod2.z.boolean(),
+  scope: import_zod2.z.enum(["artifact", "publisher", "domain", "none"]),
+  item: guardWatchlistLookupMatchSchema.nullable()
+});
+var guardPainSignalSchema = import_zod2.z.object({
+  signalId: import_zod2.z.string(),
+  signalName: import_zod2.z.string(),
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  harness: import_zod2.z.string(),
+  latestSummary: import_zod2.z.string(),
+  firstSeenAt: import_zod2.z.string(),
+  lastSeenAt: import_zod2.z.string(),
+  count: import_zod2.z.number(),
+  source: import_zod2.z.literal("scanner"),
+  publisher: import_zod2.z.string().optional()
+});
+var guardPainSignalListResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  items: import_zod2.z.array(guardPainSignalSchema)
+});
+var guardPainSignalAggregateSchema = import_zod2.z.object({
+  artifactId: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  signalName: import_zod2.z.string(),
+  latestSummary: import_zod2.z.string(),
+  firstSeenAt: import_zod2.z.string(),
+  lastSeenAt: import_zod2.z.string(),
+  totalCount: import_zod2.z.number(),
+  consumerCount: import_zod2.z.number(),
+  harnesses: import_zod2.z.array(import_zod2.z.string()),
+  publishers: import_zod2.z.array(import_zod2.z.string())
+});
+var guardPainSignalAggregateResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  summary: import_zod2.z.object({
+    totalSignals: import_zod2.z.number(),
+    uniqueArtifacts: import_zod2.z.number(),
+    uniqueConsumers: import_zod2.z.number()
+  }),
+  items: import_zod2.z.array(guardPainSignalAggregateSchema)
+});
+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 guardPreflightEvidenceSchema = import_zod2.z.object({
+  category: import_zod2.z.enum([
+    "policy",
+    "trust",
+    "watchlist",
+    "team-policy",
+    "exception"
+  ]),
+  source: import_zod2.z.string(),
+  detail: import_zod2.z.string()
+});
+var guardPreflightRequestSchema = import_zod2.z.object({
+  harness: import_zod2.z.string(),
+  artifactName: import_zod2.z.string(),
+  artifactType: import_zod2.z.enum(["skill", "plugin"]),
+  artifactId: import_zod2.z.string().optional(),
+  artifactSlug: import_zod2.z.string().optional(),
+  artifactHash: import_zod2.z.string().optional(),
+  publisher: import_zod2.z.string().optional(),
+  domain: import_zod2.z.string().optional(),
+  launchSummary: import_zod2.z.string().optional(),
+  capabilities: import_zod2.z.array(import_zod2.z.string()).optional(),
+  workspacePath: import_zod2.z.string().optional()
+});
+var guardPreflightVerdictResponseSchema = import_zod2.z.object({
+  generatedAt: import_zod2.z.string(),
+  principal: guardPrincipalSchema,
+  decision: import_zod2.z.enum(["allow", "review", "block"]),
+  recommendation: import_zod2.z.enum(["monitor", "review", "block"]),
+  rationale: import_zod2.z.string(),
+  category: import_zod2.z.enum(["exception", "team-policy", "watchlist", "trust", "policy"]).optional(),
+  confidence: import_zod2.z.number().optional(),
+  freshnessTimestamp: import_zod2.z.string().optional(),
+  evidenceSources: import_zod2.z.array(import_zod2.z.string()).optional(),
+  scope: import_zod2.z.enum(["artifact", "publisher", "domain", "policy"]),
+  matchedEvidence: import_zod2.z.array(guardPreflightEvidenceSchema),
+  matchedException: guardExceptionItemSchema.nullable(),
+  trustMatch: guardTrustMatchSchema.nullable()
+});
+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()),
+  blockedPublishers: import_zod2.z.array(import_zod2.z.string()).optional(),
+  blockedDomains: import_zod2.z.array(import_zod2.z.string()).optional(),
+  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(),
@@ -1473,13 +1832,11 @@ 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(skillSecurityBreakdownFindingSchema).optional(),
-  summary: skillSecurityBreakdownSummarySchema.optional(),
+  findings: import_zod2.z.array(jsonValueSchema).optional(),
+  summary: jsonValueSchema.optional(),
   generatedAt: import_zod2.z.string().nullable().optional(),
   scannerVersion: import_zod2.z.string().nullable().optional()
 }).passthrough();
@@ -3966,6 +4323,32 @@ async function getGuardBillingBalance(client) {
     "guard billing balance response"
   );
 }
+async function getGuardFeed(client, limit) {
+  const params = new URLSearchParams();
+  if (typeof limit === "number" && Number.isFinite(limit) && Math.trunc(limit) > 0) {
+    params.set("limit", String(Math.trunc(limit)));
+  }
+  const query = params.toString();
+  const suffix = query ? `?${query}` : "";
+  const raw = await client.requestJson(`/guard/feed${suffix}`, {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardFeedResponseSchema,
+    "guard feed response"
+  );
+}
+async function getGuardOverview(client) {
+  const raw = await client.requestJson("/guard/overview", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardOverviewResponseSchema,
+    "guard overview response"
+  );
+}
 async function getGuardTrustByHash(client, sha256) {
   const normalizedHash = sha256.trim();
   if (!normalizedHash) {
@@ -4013,10 +4396,336 @@ async function getGuardRevocations(client) {
     "guard revocations response"
   );
 }
+async function fetchGuardAdvisories(client) {
+  const raw = await client.requestJson("/guard/advisories", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardRevocationResponseSchema,
+    "guard advisories response"
+  );
+}
+async function fetchGuardPolicy(client) {
+  const raw = await client.requestJson("/guard/policy/fetch", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardPolicySchema,
+    "guard policy 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 exportGuardArtifactAbom(client, artifactId) {
+  const normalizedArtifactId = artifactId.trim();
+  if (!normalizedArtifactId) {
+    throw new Error("artifactId is required");
+  }
+  const raw = await client.requestJson(
+    `/guard/abom/${encodeURIComponent(normalizedArtifactId)}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
+    raw,
+    guardAbomResponseSchema,
+    "guard artifact 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 lookupGuardWatchlist(client, payload) {
+  const raw = await client.requestJson("/guard/watchlist/lookup", {
+    method: "POST",
+    body: payload
+  });
+  return client.parseWithSchema(
+    raw,
+    guardWatchlistLookupResponseSchema,
+    "guard watchlist lookup response"
+  );
+}
+async function getGuardPainSignals(client) {
+  const raw = await client.requestJson("/guard/signals/pain", {
+    method: "GET"
+  });
+  return client.parseWithSchema(
+    raw,
+    guardPainSignalListResponseSchema,
+    "guard pain signals response"
+  );
+}
+async function getGuardAggregatedPainSignals(client) {
+  const raw = await client.requestJson(
+    "/guard/signals/pain/aggregate",
+    {
+      method: "GET"
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    guardPainSignalAggregateResponseSchema,
+    "guard aggregated pain signals response"
+  );
+}
+async function getGuardPreflightVerdict(client, path, payload) {
+  const raw = await client.requestJson(path, {
+    method: "POST",
+    body: payload
+  });
+  return client.parseWithSchema(
+    raw,
+    guardPreflightVerdictResponseSchema,
+    "guard preflight verdict response"
+  );
+}
+async function getGuardPreInstallVerdict(client, payload) {
+  return getGuardPreflightVerdict(
+    client,
+    "/guard/verdict/pre-install",
+    payload
+  );
+}
+async function getGuardPreExecutionVerdict(client, payload) {
+  return getGuardPreflightVerdict(
+    client,
+    "/guard/verdict/pre-execution",
+    payload
+  );
+}
+async function ingestGuardPainSignals(client, items) {
+  const raw = await client.requestJson("/guard/signals/pain", {
+    method: "POST",
+    body: { items }
+  });
+  return client.parseWithSchema(
+    raw,
+    guardPainSignalListResponseSchema,
+    "guard pain signals response"
+  );
+}
+async function submitGuardReceipts(client, payload) {
+  const raw = await client.requestJson("/guard/receipts/submit", {
+    method: "POST",
+    body: payload
+  });
+  return client.parseWithSchema(
+    raw,
+    guardReceiptSyncResponseSchema,
+    "guard receipt submit 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 requestGuardException(client, payload) {
+  const raw = await client.requestJson("/guard/exceptions/request", {
+    method: "POST",
+    body: payload
+  });
+  return client.parseWithSchema(
+    raw,
+    guardExceptionListResponseSchema,
+    "guard exception request response"
+  );
+}
+async function syncGuardInventory(client, payload) {
+  const raw = await client.requestJson("/guard/inventory/sync", {
+    method: "POST",
+    body: payload
+  });
+  return client.parseWithSchema(
+    raw,
+    guardReceiptSyncResponseSchema,
+    "guard inventory sync 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",
-    headers: { "content-type": "application/json" },
     body: payload
   });
   return client.parseWithSchema(
@@ -5841,6 +6550,12 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async getGuardBillingBalance() {
     return getGuardBillingBalance(this);
   }
+  async getGuardFeed(limit) {
+    return getGuardFeed(this, limit);
+  }
+  async getGuardOverview() {
+    return getGuardOverview(this);
+  }
   async getGuardTrustByHash(sha256) {
     return getGuardTrustByHash(this, sha256);
   }
@@ -5850,9 +6565,96 @@ var RegistryBrokerClient = class _RegistryBrokerClient {
   async getGuardRevocations() {
     return getGuardRevocations(this);
   }
+  async fetchGuardAdvisories() {
+    return fetchGuardAdvisories(this);
+  }
+  async fetchGuardPolicy() {
+    return fetchGuardPolicy(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 exportGuardArtifactAbom(artifactId) {
+    return exportGuardArtifactAbom(this, artifactId);
+  }
+  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 lookupGuardWatchlist(payload) {
+    return lookupGuardWatchlist(this, payload);
+  }
+  async getGuardPainSignals() {
+    return getGuardPainSignals(this);
+  }
+  async getGuardAggregatedPainSignals() {
+    return getGuardAggregatedPainSignals(this);
+  }
+  async getGuardPreInstallVerdict(payload) {
+    return getGuardPreInstallVerdict(this, payload);
+  }
+  async getGuardPreExecutionVerdict(payload) {
+    return getGuardPreExecutionVerdict(this, payload);
+  }
+  async addGuardWatchlistItem(payload) {
+    return addGuardWatchlistItem(this, payload);
+  }
+  async removeGuardWatchlistItem(artifactId) {
+    return removeGuardWatchlistItem(this, artifactId);
+  }
+  async addGuardException(payload) {
+    return addGuardException(this, payload);
+  }
+  async requestGuardException(payload) {
+    return requestGuardException(this, payload);
+  }
+  async removeGuardException(exceptionId) {
+    return removeGuardException(this, exceptionId);
+  }
+  async ingestGuardPainSignals(items) {
+    return ingestGuardPainSignals(this, items);
+  }
   async syncGuardReceipts(payload) {
     return syncGuardReceipts(this, payload);
   }
+  async syncGuardInventory(payload) {
+    return syncGuardInventory(this, payload);
+  }
+  async submitGuardReceipts(payload) {
+    return submitGuardReceipts(this, payload);
+  }
+  async getGuardTeamPolicyPack() {
+    return getGuardTeamPolicyPack(this);
+  }
+  async updateGuardTeamPolicyPack(payload) {
+    return updateGuardTeamPolicyPack(this, payload);
+  }
   async createHbarPurchaseIntent(payload) {
     return createHbarPurchaseIntent(this, payload);
   }