@hashgraphonline/standards-sdk 0.1.177 → 0.1.179

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

@@ -9043,6 +9043,339 @@ objectType({
   transactionId: stringType(),
   consensusTimestamp: stringType().nullable().optional()
 });
+const creditProviderSummarySchema = objectType({
+  name: stringType(),
+  publishableKey: stringType().optional(),
+  currency: stringType().optional(),
+  centsPerHbar: numberType().nullable().optional()
+});
+objectType({
+  providers: arrayType(creditProviderSummarySchema)
+});
+objectType({
+  accountId: stringType(),
+  balance: numberType(),
+  balanceRecord: jsonValueSchema.optional(),
+  timestamp: stringType().optional()
+});
+const guardPlanIdSchema = enumType(["free", "pro", "team", "enterprise"]);
+const guardBucketBalanceSchema = objectType({
+  bucketId: enumType([
+    "registry_credits",
+    "chat_credits",
+    "guard_credits",
+    "org_policy_credits"
+  ]),
+  label: stringType(),
+  availableCredits: numberType(),
+  includedMonthlyCredits: numberType().nullable().optional()
+});
+const guardPrincipalSchema = objectType({
+  signedIn: booleanType(),
+  userId: stringType().optional(),
+  email: stringType().optional(),
+  accountId: stringType().optional(),
+  stripeCustomerId: stringType().optional(),
+  roles: arrayType(stringType())
+});
+const guardEntitlementsSchema = objectType({
+  planId: guardPlanIdSchema,
+  includedMonthlyCredits: numberType(),
+  deviceLimit: numberType(),
+  retentionDays: numberType(),
+  syncEnabled: booleanType(),
+  premiumFeedsEnabled: booleanType(),
+  teamPolicyEnabled: booleanType()
+});
+objectType({
+  principal: guardPrincipalSchema,
+  entitlements: guardEntitlementsSchema,
+  balance: objectType({
+    accountId: stringType(),
+    availableCredits: numberType()
+  }).nullable(),
+  bucketingMode: enumType(["shared-ledger", "product-bucketed"]),
+  buckets: arrayType(guardBucketBalanceSchema)
+});
+objectType({
+  generatedAt: stringType(),
+  bucketingMode: enumType(["shared-ledger", "product-bucketed"]),
+  buckets: arrayType(guardBucketBalanceSchema)
+});
+const guardTrustMatchSchema = objectType({
+  artifactId: stringType(),
+  artifactName: stringType(),
+  artifactType: enumType(["skill", "plugin"]),
+  artifactSlug: stringType(),
+  recommendation: enumType(["monitor", "review", "block"]),
+  verified: booleanType(),
+  safetyScore: numberType().nullable().optional(),
+  trustScore: numberType().nullable().optional(),
+  href: stringType().optional(),
+  ecosystem: stringType().optional()
+});
+objectType({
+  generatedAt: stringType(),
+  query: objectType({
+    sha256: stringType()
+  }),
+  match: guardTrustMatchSchema.nullable(),
+  evidence: arrayType(stringType())
+});
+objectType({
+  generatedAt: stringType(),
+  query: objectType({
+    ecosystem: stringType().optional(),
+    name: stringType().optional(),
+    version: stringType().optional()
+  }),
+  items: arrayType(guardTrustMatchSchema)
+});
+const guardRevocationSchema = objectType({
+  id: stringType(),
+  artifactId: stringType(),
+  artifactName: stringType(),
+  reason: stringType(),
+  severity: enumType(["low", "medium", "high"]),
+  publishedAt: stringType()
+});
+objectType({
+  generatedAt: stringType(),
+  items: arrayType(guardRevocationSchema)
+});
+const guardReceiptSchema = objectType({
+  receiptId: stringType(),
+  capturedAt: stringType(),
+  harness: stringType(),
+  deviceId: stringType(),
+  deviceName: stringType(),
+  artifactId: stringType(),
+  artifactName: stringType(),
+  artifactType: enumType(["skill", "plugin"]),
+  artifactSlug: stringType(),
+  artifactHash: stringType(),
+  policyDecision: enumType([
+    "allow",
+    "warn",
+    "block",
+    "review",
+    "require-reapproval",
+    "sandbox-required"
+  ]),
+  recommendation: enumType(["monitor", "review", "block"]),
+  changedSinceLastApproval: booleanType(),
+  publisher: stringType().optional(),
+  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(),
+  inventoryStored: numberType().optional(),
+  inventoryDiff: guardInventoryDiffResponseSchema.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
+});
+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 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 guardTeamPolicyAuditItemSchema = objectType({
+  changedAt: stringType(),
+  actor: stringType(),
+  change: enumType(["created", "updated"]),
+  summary: stringType()
+});
+objectType({
+  name: stringType(),
+  sharedHarnessDefaults: recordType(stringType(), enumType(["observe", "prompt", "enforce"])),
+  allowedPublishers: arrayType(stringType()),
+  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(),
+  transactionId: stringType(),
+  network: enumType(["mainnet", "testnet"]),
+  accountId: stringType(),
+  treasuryAccountId: stringType(),
+  hbarAmount: numberType(),
+  credits: numberType(),
+  tinybarAmount: numberType(),
+  memo: stringType(),
+  centsPerHbar: numberType(),
+  validStart: stringType(),
+  validDurationSeconds: numberType(),
+  requiresManualSubmit: literalType(true),
+  purchaseId: stringType()
+});
 const x402SettlementSchema = objectType({
   success: booleanType().optional(),
   transaction: stringType().optional(),
@@ -9425,11 +9758,13 @@ objectType({
   name: stringType(),
   items: arrayType(skillDeprecationRecordSchema)
 }).passthrough();
+const skillSecurityBreakdownFindingSchema = recordType(jsonValueSchema);
+const skillSecurityBreakdownSummarySchema = recordType(jsonValueSchema);
 objectType({
   jobId: stringType(),
   score: numberType().nullable().optional(),
-  findings: arrayType(unknownType()).optional(),
-  summary: unknownType().optional(),
+  findings: arrayType(skillSecurityBreakdownFindingSchema).optional(),
+  summary: skillSecurityBreakdownSummarySchema.optional(),
   generatedAt: stringType().nullable().optional(),
   scannerVersion: stringType().nullable().optional()
 }).passthrough();
@@ -9949,9 +10284,16 @@ objectType({
 const isBrowser$1 = typeof window !== "undefined" && typeof window.document !== "undefined";
 let nodeRequire;
 const 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") {
@@ -30619,9 +30961,12 @@ async function loadNodeModules() {
     Logger$1.getInstance({
       module: "Inscriber",
       level: "warn"
-    }).warn("Node.js modules not available, file path operations will be disabled", {
-      error: error instanceof Error ? error.message : String(error)
-    });
+    }).warn(
+      "Node.js modules not available, file path operations will be disabled",
+      {
+        error: error instanceof Error ? error.message : String(error)
+      }
+    );
   }
 }
 const COST_LOOKUP_ATTEMPTS = 3;