@hashgraphonline/standards-sdk 0.1.178 → 0.1.180

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

@@ -9072,10 +9072,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({
@@ -9102,6 +9106,65 @@ 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()
+});
+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(),
@@ -9137,13 +9200,19 @@ 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()
 });
 objectType({
   generatedAt: stringType(),
   items: arrayType(guardRevocationSchema)
 });
-objectType({
+const guardReceiptSchema = objectType({
   receiptId: stringType(),
   capturedAt: stringType(),
   harness: stringType(),
@@ -9168,9 +9237,299 @@ objectType({
   capabilities: arrayType(stringType()),
   summary: stringType()
 });
+const guardHistoryArtifactSchema = objectType({
+  artifactId: stringType(),
+  artifactName: stringType(),
+  artifactType: enumType(["skill", "plugin"]),
+  artifactSlug: stringType(),
+  publisher: stringType().optional(),
+  harnesses: arrayType(stringType()),
+  eventCount: numberType(),
+  firstSeenAt: stringType(),
+  lastSeenAt: stringType(),
+  latestDecision: enumType([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  latestRecommendation: enumType(["monitor", "review", "block"])
+});
+objectType({
+  generatedAt: stringType(),
+  artifacts: arrayType(guardHistoryArtifactSchema)
+});
+const guardInventoryArtifactSchema = objectType({
+  artifactId: stringType(),
+  artifactName: stringType(),
+  artifactType: enumType(["skill", "plugin"]),
+  artifactSlug: stringType(),
+  publisher: stringType().optional(),
+  harnesses: arrayType(stringType()),
+  devices: arrayType(stringType()),
+  eventCount: numberType(),
+  firstSeenAt: stringType(),
+  lastSeenAt: stringType(),
+  latestDecision: enumType([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  latestRecommendation: enumType(["monitor", "review", "block"]),
+  latestHash: stringType(),
+  latestSummary: stringType()
+});
+const guardInventoryDiffEntrySchema = objectType({
+  artifactId: stringType(),
+  artifactName: stringType(),
+  artifactType: enumType(["skill", "plugin"]),
+  changeType: enumType(["new", "changed", "removed"]),
+  previousHash: stringType().nullable(),
+  currentHash: stringType().nullable()
+});
+const guardInventoryDiffResponseSchema = objectType({
+  generatedAt: stringType(),
+  items: arrayType(guardInventoryDiffEntrySchema)
+});
 objectType({
   syncedAt: stringType(),
-  receiptsStored: numberType()
+  receiptsStored: numberType(),
+  inventoryStored: numberType().optional(),
+  inventoryDiff: guardInventoryDiffResponseSchema.optional(),
+  advisories: arrayType(guardRevocationSchema).optional(),
+  policy: guardPolicySchema.optional(),
+  alertPreferences: lazyType(() => guardAlertPreferencesSchema).optional(),
+  exceptions: arrayType(lazyType(() => guardExceptionItemSchema)).optional(),
+  teamPolicyPack: lazyType(() => guardTeamPolicyPackSchema).optional()
+});
+objectType({
+  generatedAt: stringType(),
+  items: arrayType(guardInventoryArtifactSchema)
+});
+const guardAbomSummarySchema = objectType({
+  totalArtifacts: numberType(),
+  totalDevices: numberType(),
+  totalHarnesses: numberType(),
+  blockedArtifacts: numberType(),
+  reviewArtifacts: numberType()
+});
+objectType({
+  generatedAt: stringType(),
+  summary: guardAbomSummarySchema,
+  items: arrayType(guardInventoryArtifactSchema)
+});
+const guardTimelineEventSchema = objectType({
+  receiptId: stringType(),
+  capturedAt: stringType(),
+  harness: stringType(),
+  deviceId: stringType(),
+  deviceName: stringType(),
+  artifactHash: stringType(),
+  policyDecision: enumType([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  recommendation: enumType(["monitor", "review", "block"]),
+  changedSinceLastApproval: booleanType(),
+  summary: stringType(),
+  capabilities: arrayType(stringType()),
+  publisher: stringType().optional()
+});
+objectType({
+  generatedAt: stringType(),
+  artifactId: stringType(),
+  artifactName: stringType(),
+  artifactType: enumType(["skill", "plugin"]),
+  artifactSlug: stringType(),
+  events: arrayType(guardTimelineEventSchema)
+});
+const guardReceiptExportSummarySchema = objectType({
+  totalReceipts: numberType(),
+  blockedCount: numberType(),
+  reviewCount: numberType(),
+  approvedCount: numberType()
+});
+const guardExportSignatureSchema = objectType({
+  algorithm: enumType(["hmac-sha256", "none"]),
+  digest: stringType()
+});
+objectType({
+  generatedAt: stringType(),
+  summary: guardReceiptExportSummarySchema,
+  provenanceSummary: arrayType(stringType()),
+  items: arrayType(guardReceiptSchema),
+  signature: guardExportSignatureSchema
+});
+const guardAlertPreferencesSchema = objectType({
+  emailEnabled: booleanType(),
+  digestMode: enumType(["immediate", "daily", "weekly"]),
+  watchlistEnabled: booleanType(),
+  advisoriesEnabled: booleanType(),
+  repeatedWarningsEnabled: booleanType(),
+  teamAlertsEnabled: booleanType(),
+  updatedAt: stringType()
+});
+const guardWatchlistItemSchema = objectType({
+  artifactId: stringType(),
+  artifactName: stringType(),
+  artifactType: enumType(["skill", "plugin"]),
+  artifactSlug: stringType(),
+  reason: stringType(),
+  source: enumType(["manual", "synced", "team-policy"]),
+  createdAt: stringType()
+});
+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()
+});
+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()
+});
+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())
+});
+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"]),
+  harness: stringType().nullable(),
+  artifactId: stringType().nullable(),
+  publisher: stringType().nullable(),
+  reason: stringType(),
+  owner: stringType(),
+  source: enumType(["manual", "team-policy"]),
+  expiresAt: stringType(),
+  createdAt: stringType(),
+  updatedAt: stringType()
+});
+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()
+});
+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(),
+  change: enumType(["created", "updated"]),
+  summary: stringType()
+});
+const guardTeamPolicyPackSchema = objectType({
+  name: stringType(),
+  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(),
+  auditTrail: arrayType(guardTeamPolicyAuditItemSchema)
+});
+const guardDeviceSchema = objectType({
+  deviceId: stringType(),
+  deviceName: stringType(),
+  harnesses: arrayType(stringType()),
+  receiptCount: numberType(),
+  lastSeenAt: stringType()
+});
+objectType({
+  generatedAt: stringType(),
+  items: arrayType(guardDeviceSchema)
 });
 objectType({
   transaction: stringType(),
@@ -9570,13 +9929,11 @@ objectType({
   name: stringType(),
   items: arrayType(skillDeprecationRecordSchema)
 }).passthrough();
-const skillSecurityBreakdownFindingSchema = recordType(jsonValueSchema);
-const skillSecurityBreakdownSummarySchema = recordType(jsonValueSchema);
 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();