@hashgraphonline/standards-sdk 0.1.179 → 0.1.180

package/dist/browser-root/standards-sdk.root-browser.js

@@ -6842,10 +6842,14 @@ const guardBucketBalanceSchema = objectType({
 });
 const guardPrincipalSchema = objectType({
   signedIn: booleanType(),
+  principalType: enumType(["user", "service"]).default("user"),
   userId: stringType().optional(),
   email: stringType().optional(),
   accountId: stringType().optional(),
   stripeCustomerId: stringType().optional(),
+  serviceId: stringType().optional(),
+  workspaceId: stringType().optional(),
+  serviceLabel: stringType().optional(),
   roles: arrayType(stringType())
 });
 const guardEntitlementsSchema = objectType({
@@ -6872,6 +6876,65 @@ const guardBalanceResponseSchema = objectType({
   bucketingMode: enumType(["shared-ledger", "product-bucketed"]),
   buckets: arrayType(guardBucketBalanceSchema)
 });
+const guardFeedItemSchema = objectType({
+  id: stringType(),
+  artifactType: enumType(["skill", "plugin"]),
+  slug: stringType(),
+  name: stringType(),
+  href: stringType(),
+  ecosystem: stringType().optional(),
+  safetyScore: numberType().nullable().optional(),
+  trustScore: numberType().nullable().optional(),
+  verified: booleanType(),
+  recommendation: enumType(["monitor", "review", "block"]),
+  updatedAt: stringType()
+});
+const guardFeedSummarySchema = objectType({
+  total: numberType(),
+  monitorCount: numberType(),
+  reviewCount: numberType(),
+  blockCount: numberType()
+});
+const guardFeedResponseSchema = objectType({
+  generatedAt: stringType(),
+  items: arrayType(guardFeedItemSchema),
+  summary: guardFeedSummarySchema
+});
+const guardIntegrationSchema = objectType({
+  id: enumType(["openclaw", "hermes"]),
+  name: stringType(),
+  status: enumType(["available", "planned"]),
+  href: stringType().nullable(),
+  summary: stringType()
+});
+const guardActionItemSchema = objectType({
+  title: stringType(),
+  description: stringType(),
+  href: stringType()
+});
+const guardOverviewResponseSchema = objectType({
+  generatedAt: stringType(),
+  principal: guardPrincipalSchema,
+  entitlements: guardEntitlementsSchema,
+  balance: objectType({
+    accountId: stringType(),
+    availableCredits: numberType()
+  }).nullable(),
+  trustFeed: guardFeedResponseSchema,
+  integrations: arrayType(guardIntegrationSchema),
+  actionItems: arrayType(guardActionItemSchema)
+});
+const guardPolicySchema = objectType({
+  mode: enumType(["observe", "prompt", "enforce"]),
+  defaultAction: enumType(["allow", "warn", "block"]),
+  unknownPublisherAction: enumType(["review", "block", "allow"]),
+  changedHashAction: enumType(["allow", "warn", "require-reapproval", "block"]),
+  newNetworkDomainAction: enumType(["allow", "warn", "block"]),
+  subprocessAction: enumType(["allow", "warn", "block"]),
+  telemetryEnabled: booleanType(),
+  syncEnabled: booleanType(),
+  updatedAt: stringType()
+});
 const guardTrustMatchSchema = objectType({
   artifactId: stringType(),
   artifactName: stringType(),
@@ -6907,7 +6970,13 @@ const guardRevocationSchema = objectType({
   artifactName: stringType(),
   reason: stringType(),
   severity: enumType(["low", "medium", "high"]),
-  publishedAt: stringType()
+  publishedAt: stringType(),
+  confidence: numberType().optional(),
+  remediation: stringType().nullable().optional(),
+  scope: enumType(["artifact", "publisher", "domain", "workspace", "ecosystem"]).optional(),
+  source: stringType().optional(),
+  firstSeenAt: stringType().optional(),
+  lastUpdatedAt: stringType().optional()
 });
 const guardRevocationResponseSchema = objectType({
   generatedAt: stringType(),
@@ -7001,7 +7070,12 @@ const guardReceiptSyncResponseSchema = objectType({
   syncedAt: stringType(),
   receiptsStored: numberType(),
   inventoryStored: numberType().optional(),
-  inventoryDiff: guardInventoryDiffResponseSchema.optional()
+  inventoryDiff: guardInventoryDiffResponseSchema.optional(),
+  advisories: arrayType(guardRevocationSchema).optional(),
+  policy: guardPolicySchema.optional(),
+  alertPreferences: lazyType(() => guardAlertPreferencesSchema).optional(),
+  exceptions: arrayType(lazyType(() => guardExceptionItemSchema)).optional(),
+  teamPolicyPack: lazyType(() => guardTeamPolicyPackSchema).optional()
 });
 const guardInventoryResponseSchema = objectType({
   generatedAt: stringType(),
@@ -7087,6 +7161,59 @@ const guardWatchlistResponseSchema = objectType({
   generatedAt: stringType(),
   items: arrayType(guardWatchlistItemSchema)
 });
+const guardWatchlistLookupMatchSchema = objectType({
+  artifactId: stringType().nullable(),
+  publisher: stringType().nullable(),
+  domain: stringType().nullable(),
+  source: enumType(["watchlist", "team-policy"]),
+  reason: stringType()
+});
+const guardWatchlistLookupResponseSchema = objectType({
+  generatedAt: stringType(),
+  matched: booleanType(),
+  scope: enumType(["artifact", "publisher", "domain", "none"]),
+  item: guardWatchlistLookupMatchSchema.nullable()
+});
+const guardPainSignalSchema = objectType({
+  signalId: stringType(),
+  signalName: stringType(),
+  artifactId: stringType(),
+  artifactName: stringType(),
+  artifactType: enumType(["skill", "plugin"]),
+  harness: stringType(),
+  latestSummary: stringType(),
+  firstSeenAt: stringType(),
+  lastSeenAt: stringType(),
+  count: numberType(),
+  source: literalType("scanner"),
+  publisher: stringType().optional()
+});
+const guardPainSignalListResponseSchema = objectType({
+  generatedAt: stringType(),
+  items: arrayType(guardPainSignalSchema)
+});
+const guardPainSignalAggregateSchema = objectType({
+  artifactId: stringType(),
+  artifactName: stringType(),
+  artifactType: enumType(["skill", "plugin"]),
+  signalName: stringType(),
+  latestSummary: stringType(),
+  firstSeenAt: stringType(),
+  lastSeenAt: stringType(),
+  totalCount: numberType(),
+  consumerCount: numberType(),
+  harnesses: arrayType(stringType()),
+  publishers: arrayType(stringType())
+});
+const guardPainSignalAggregateResponseSchema = objectType({
+  generatedAt: stringType(),
+  summary: objectType({
+    totalSignals: numberType(),
+    uniqueArtifacts: numberType(),
+    uniqueConsumers: numberType()
+  }),
+  items: arrayType(guardPainSignalAggregateSchema)
+});
 const guardExceptionItemSchema = objectType({
   exceptionId: stringType(),
   scope: enumType(["artifact", "publisher", "harness", "global"]),
@@ -7104,6 +7231,45 @@ const guardExceptionListResponseSchema = objectType({
   generatedAt: stringType(),
   items: arrayType(guardExceptionItemSchema)
 });
+const guardPreflightEvidenceSchema = objectType({
+  category: enumType([
+    "policy",
+    "trust",
+    "watchlist",
+    "team-policy",
+    "exception"
+  ]),
+  source: stringType(),
+  detail: stringType()
+});
+objectType({
+  harness: stringType(),
+  artifactName: stringType(),
+  artifactType: enumType(["skill", "plugin"]),
+  artifactId: stringType().optional(),
+  artifactSlug: stringType().optional(),
+  artifactHash: stringType().optional(),
+  publisher: stringType().optional(),
+  domain: stringType().optional(),
+  launchSummary: stringType().optional(),
+  capabilities: arrayType(stringType()).optional(),
+  workspacePath: stringType().optional()
+});
+const guardPreflightVerdictResponseSchema = objectType({
+  generatedAt: stringType(),
+  principal: guardPrincipalSchema,
+  decision: enumType(["allow", "review", "block"]),
+  recommendation: enumType(["monitor", "review", "block"]),
+  rationale: stringType(),
+  category: enumType(["exception", "team-policy", "watchlist", "trust", "policy"]).optional(),
+  confidence: numberType().optional(),
+  freshnessTimestamp: stringType().optional(),
+  evidenceSources: arrayType(stringType()).optional(),
+  scope: enumType(["artifact", "publisher", "domain", "policy"]),
+  matchedEvidence: arrayType(guardPreflightEvidenceSchema),
+  matchedException: guardExceptionItemSchema.nullable(),
+  trustMatch: guardTrustMatchSchema.nullable()
+});
 const guardTeamPolicyAuditItemSchema = objectType({
   changedAt: stringType(),
   actor: stringType(),
@@ -7112,8 +7278,13 @@ const guardTeamPolicyAuditItemSchema = objectType({
 });
 const guardTeamPolicyPackSchema = objectType({
   name: stringType(),
-  sharedHarnessDefaults: recordType(stringType(), enumType(["observe", "prompt", "enforce"])),
+  sharedHarnessDefaults: recordType(
+    stringType(),
+    enumType(["observe", "prompt", "enforce"])
+  ),
   allowedPublishers: arrayType(stringType()),
+  blockedPublishers: arrayType(stringType()).optional(),
+  blockedDomains: arrayType(stringType()).optional(),
   blockedArtifacts: arrayType(stringType()),
   alertChannel: enumType(["email", "slack", "teams", "webhook"]),
   updatedAt: stringType(),
@@ -7528,13 +7699,11 @@ const skillDeprecationsResponseSchema = objectType({
   name: stringType(),
   items: arrayType(skillDeprecationRecordSchema)
 }).passthrough();
-const skillSecurityBreakdownFindingSchema = recordType(jsonValueSchema);
-const skillSecurityBreakdownSummarySchema = recordType(jsonValueSchema);
 const skillSecurityBreakdownResponseSchema = objectType({
   jobId: stringType(),
   score: numberType().nullable().optional(),
-  findings: arrayType(skillSecurityBreakdownFindingSchema).optional(),
-  summary: skillSecurityBreakdownSummarySchema.optional(),
+  findings: arrayType(jsonValueSchema).optional(),
+  summary: jsonValueSchema.optional(),
   generatedAt: stringType().nullable().optional(),
   scannerVersion: stringType().nullable().optional()
 }).passthrough();
@@ -9988,6 +10157,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, sha2562) {
   const normalizedHash = sha2562.trim();
   if (!normalizedHash) {
@@ -10035,6 +10230,26 @@ 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"
@@ -10080,6 +10295,21 @@ async function exportGuardAbom(client) {
     "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"
@@ -10151,6 +10381,87 @@ async function getGuardWatchlist(client) {
     "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",
@@ -10188,6 +10499,28 @@ async function addGuardException(client, payload) {
     "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) {
@@ -12036,6 +12369,12 @@ class RegistryBrokerClient {
   async getGuardBillingBalance() {
     return getGuardBillingBalance(this);
   }
+  async getGuardFeed(limit) {
+    return getGuardFeed(this, limit);
+  }
+  async getGuardOverview() {
+    return getGuardOverview(this);
+  }
   async getGuardTrustByHash(sha2562) {
     return getGuardTrustByHash(this, sha2562);
   }
@@ -12045,6 +12384,12 @@ class RegistryBrokerClient {
   async getGuardRevocations() {
     return getGuardRevocations(this);
   }
+  async fetchGuardAdvisories() {
+    return fetchGuardAdvisories(this);
+  }
+  async fetchGuardPolicy() {
+    return fetchGuardPolicy(this);
+  }
   async getGuardInventory() {
     return getGuardInventory(this);
   }
@@ -12060,6 +12405,9 @@ class RegistryBrokerClient {
   async exportGuardAbom() {
     return exportGuardAbom(this);
   }
+  async exportGuardArtifactAbom(artifactId) {
+    return exportGuardArtifactAbom(this, artifactId);
+  }
   async exportGuardReceipts() {
     return exportGuardReceipts(this);
   }
@@ -12078,6 +12426,21 @@ class RegistryBrokerClient {
   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);
   }
@@ -12087,12 +12450,24 @@ class RegistryBrokerClient {
   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);
   }