@hashgraphonline/standards-sdk 0.1.185 → 0.1.187

package/dist/es/standards-sdk.es186.js

@@ -1,687 +1,114 @@
-import { guardSessionResponseSchema, guardBalanceResponseSchema, guardFeedResponseSchema, guardOverviewResponseSchema, guardTrustByHashResponseSchema, guardTrustResolveResponseSchema, guardRevocationResponseSchema, guardPolicySchema, guardInventoryResponseSchema, guardReceiptHistoryResponseSchema, guardArtifactTimelineResponseSchema, guardInventoryDiffResponseSchema, guardAbomResponseSchema, guardReceiptExportResponseSchema, guardDeviceListResponseSchema, guardAlertPreferencesSchema, guardExceptionListResponseSchema, guardWatchlistResponseSchema, guardWatchlistLookupResponseSchema, guardPainSignalListResponseSchema, guardPainSignalAggregateResponseSchema, guardReceiptSyncResponseSchema, guardTeamPolicyPackSchema, guardPreflightVerdictResponseSchema } from "./standards-sdk.es155.js";
-import { RegistryBrokerError } from "./standards-sdk.es149.js";
-function isStatusError(error) {
-  if (error instanceof RegistryBrokerError) {
-    return true;
+import { isBrowser } from "./standards-sdk.es141.js";
+let nodeRequire;
+const isNodeRuntime = () => typeof process !== "undefined" && Boolean(process.versions?.node);
+function resolveBuiltinModuleLoader() {
+  if (typeof process === "undefined") {
+    return void 0;
   }
-  if (typeof error !== "object" || error === null || !("status" in error)) {
-    return false;
-  }
-  return typeof Reflect.get(error, "status") === "number";
+  return process.getBuiltinModule;
 }
-function toPortalCanonicalGuardPath(path) {
-  const segments = path.split("/");
-  const findPatternStart = (size, matcher) => {
-    for (let startIndex = segments.length - size; startIndex >= 0; startIndex -= 1) {
-      if (matcher(startIndex)) {
-        return startIndex;
+function getNodeRequireSync() {
+  try {
+    const builtinModuleLoader = resolveBuiltinModuleLoader();
+    const moduleNamespace = builtinModuleLoader?.("module");
+    if (typeof moduleNamespace?.createRequire === "function") {
+      const requireFromModule = moduleNamespace.createRequire(import.meta.url);
+      if (typeof requireFromModule.resolve === "function") {
+        return requireFromModule;
       }
     }
-    return -1;
-  };
-  const replaceAt = (startIndex, consumed) => [
-    ...segments.slice(0, startIndex),
-    "api",
-    "guard",
-    ...segments.slice(startIndex + consumed)
-  ].join("/");
-  const registryStart = findPatternStart(
-    4,
-    (startIndex) => segments[startIndex] === "registry" && segments[startIndex + 1] === "api" && /^v\d+$/.test(segments[startIndex + 2] ?? "") && segments[startIndex + 3] === "guard"
-  );
-  if (registryStart >= 0) {
-    return replaceAt(registryStart, 4);
-  }
-  const apiVersionStart = findPatternStart(
-    3,
-    (startIndex) => segments[startIndex] === "api" && /^v\d+$/.test(segments[startIndex + 1] ?? "") && segments[startIndex + 2] === "guard"
-  );
-  if (apiVersionStart >= 0) {
-    return replaceAt(apiVersionStart, 3);
-  }
-  for (let index = segments.length - 1; index >= 0; index -= 1) {
-    if (segments[index] === "guard" && segments[index - 1] !== "api") {
-      return [
-        ...segments.slice(0, index),
-        "api",
-        "guard",
-        ...segments.slice(index + 1)
-      ].join("/");
+    const globalObject = typeof global !== "undefined" ? global : globalThis;
+    const runtimeRequire = globalObject.process?.mainModule?.require ?? globalObject.require ?? Function('return typeof require === "function" ? require : undefined;')();
+    if (typeof runtimeRequire === "function" && typeof runtimeRequire.resolve === "function") {
+      return runtimeRequire;
     }
-  }
-  return path;
-}
-function buildPortalCanonicalGuardUrl(baseUrl, path) {
-  const target = new URL(path, "https://guard.local");
-  const normalizedBasePath = (() => {
-    try {
-      const base = new URL(baseUrl);
-      return base.pathname.replace(/\/+$/, "");
-    } catch {
-      return baseUrl.replace(/\/+$/, "");
-    }
-  })();
-  const requestedPath = `${normalizedBasePath}${target.pathname}`;
-  const canonicalPath = toPortalCanonicalGuardPath(requestedPath);
-  const canonicalRelativePath = `${canonicalPath}${target.search}`;
-  try {
-    const base = new URL(baseUrl);
-    return `${base.origin}${canonicalRelativePath}`;
   } catch {
-    return canonicalRelativePath;
+    return null;
   }
+  return null;
 }
-async function requestPortalFirstJson(client, path, init) {
-  try {
-    return await client.requestJson(path, init);
-  } catch (error) {
-    if (isStatusError(error) && (error.status === 404 || error.status === 501)) {
-      return client.requestAbsoluteJson(
-        buildPortalCanonicalGuardUrl(client.baseUrl, path),
-        init
-      );
-    }
-    throw error;
+function isModuleNotFound(specifier, error) {
+  if (!error || typeof error !== "object") {
+    return false;
   }
-}
-async function getGuardSession(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/auth/session",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardSessionResponseSchema,
-    "guard session response"
-  );
-}
-async function getGuardEntitlements(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/entitlements",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardSessionResponseSchema,
-    "guard entitlements response"
-  );
-}
-async function getGuardBillingBalance(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/billing/balance",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardBalanceResponseSchema,
-    "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 code = Reflect.get(error, "code");
+  const message = Reflect.get(error, "message");
+  const messageText = typeof message === "string" ? message : "";
+  if (typeof code === "string" && code.includes("MODULE_NOT_FOUND")) {
+    return messageText.includes(specifier);
   }
-  const query = params.toString();
-  const suffix = query ? `?${query}` : "";
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/feed${suffix}`,
-    {
-      method: "GET"
+  if (messageText) {
+    const lowered = messageText.toLowerCase();
+    if (lowered.includes("cannot find module") || lowered.includes("module not found") || lowered.includes("cannot find package")) {
+      return lowered.includes(specifier.toLowerCase());
     }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardFeedResponseSchema,
-    "guard feed response"
-  );
-}
-async function getGuardOverview(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/overview",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardOverviewResponseSchema,
-    "guard overview response"
-  );
-}
-async function getGuardTrustByHash(client, sha256) {
-  const normalizedHash = sha256.trim();
-  if (!normalizedHash) {
-    throw new Error("sha256 is required");
   }
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/trust/by-hash/${encodeURIComponent(normalizedHash)}`,
-    { method: "GET" }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardTrustByHashResponseSchema,
-    "guard trust by hash response"
-  );
+  return false;
 }
-async function resolveGuardTrust(client, query) {
-  const params = new URLSearchParams();
-  if (query.ecosystem?.trim()) {
-    params.set("ecosystem", query.ecosystem.trim());
+async function resolveNodeRequire() {
+  if (nodeRequire !== void 0) {
+    return nodeRequire;
   }
-  if (query.name?.trim()) {
-    params.set("name", query.name.trim());
+  if (isBrowser && !isNodeRuntime()) {
+    nodeRequire = null;
+    return nodeRequire;
   }
-  if (query.version?.trim()) {
-    params.set("version", query.version.trim());
+  try {
+    nodeRequire = getNodeRequireSync();
+  } catch {
+    nodeRequire = null;
   }
-  const suffix = params.size > 0 ? `?${params.toString()}` : "";
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/trust/resolve${suffix}`,
-    { method: "GET" }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardTrustResolveResponseSchema,
-    "guard trust resolve response"
-  );
-}
-async function getGuardRevocations(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/revocations",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardRevocationResponseSchema,
-    "guard revocations response"
-  );
-}
-async function fetchGuardAdvisories(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/advisories",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardRevocationResponseSchema,
-    "guard advisories response"
-  );
-}
-async function fetchGuardPolicy(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/policy/fetch",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardPolicySchema,
-    "guard policy response"
-  );
-}
-async function getGuardInventory(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/inventory",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardInventoryResponseSchema,
-    "guard inventory response"
-  );
+  return nodeRequire;
 }
-async function getGuardReceiptHistory(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/history",
-    {
-      method: "GET"
+async function dynamicImport(specifier) {
+  try {
+    return await import(
+      /* webpackIgnore: true */
+      specifier
+    );
+  } catch (error) {
+    if (isModuleNotFound(specifier, error)) {
+      return null;
     }
-  );
-  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");
+    throw error;
   }
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/history/${encodeURIComponent(normalizedArtifactId)}`,
-    { method: "GET" }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardArtifactTimelineResponseSchema,
-    "guard artifact timeline response"
-  );
-}
-async function exportGuardAbom(client) {
-  const raw = await requestPortalFirstJson(client, "/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");
+async function optionalImport(specifier, options = {}) {
+  if (isBrowser && !isNodeRuntime()) {
+    return dynamicImport(specifier);
   }
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/abom/${encodeURIComponent(normalizedArtifactId)}`,
-    { method: "GET" }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardAbomResponseSchema,
-    "guard artifact abom response"
-  );
-}
-async function exportGuardReceipts(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/receipts/export",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardReceiptExportResponseSchema,
-    "guard receipt export response"
-  );
-}
-async function getGuardInventoryDiff(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/inventory/diff",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardInventoryDiffResponseSchema,
-    "guard inventory diff response"
-  );
-}
-async function getGuardDevices(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/devices",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardDeviceListResponseSchema,
-    "guard devices response"
-  );
-}
-async function getGuardAlertPreferences(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/alerts/preferences",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardAlertPreferencesSchema,
-    "guard alert preferences response"
-  );
-}
-async function updateGuardAlertPreferences(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/alerts/preferences",
-    {
-      method: "PUT",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardAlertPreferencesSchema,
-    "guard alert preferences response"
-  );
-}
-async function getGuardExceptions(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/exceptions",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardExceptionListResponseSchema,
-    "guard exceptions response"
-  );
-}
-async function getGuardWatchlist(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/watchlist",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardWatchlistResponseSchema,
-    "guard watchlist response"
-  );
-}
-async function lookupGuardWatchlist(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/watchlist/lookup",
-    {
-      method: "POST",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardWatchlistLookupResponseSchema,
-    "guard watchlist lookup response"
-  );
-}
-async function getGuardPainSignals(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/signals/pain",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardPainSignalListResponseSchema,
-    "guard pain signals response"
-  );
-}
-async function getGuardAggregatedPainSignals(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/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 requestPortalFirstJson(client, 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 requestPortalFirstJson(
-    client,
-    "/guard/signals/pain",
-    {
-      method: "POST",
-      body: { items }
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardPainSignalListResponseSchema,
-    "guard pain signals response"
-  );
-}
-async function submitGuardReceipts(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/receipts/submit",
-    {
-      method: "POST",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardReceiptSyncResponseSchema,
-    "guard receipt submit response"
-  );
-}
-async function addGuardWatchlistItem(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/watchlist",
-    {
-      method: "POST",
-      body: payload
+  if (!options.preferImport) {
+    const requireFn = await resolveNodeRequire();
+    if (requireFn) {
+      try {
+        return requireFn(specifier);
+      } catch (error) {
+        if (!isModuleNotFound(specifier, error)) {
+          throw error;
+        }
+      }
     }
-  );
-  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 requestPortalFirstJson(
-    client,
-    `/guard/watchlist/${encodeURIComponent(normalizedArtifactId)}`,
-    { method: "DELETE" }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardWatchlistResponseSchema,
-    "guard watchlist response"
-  );
-}
-async function addGuardException(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/exceptions",
-    {
-      method: "POST",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardExceptionListResponseSchema,
-    "guard exceptions response"
-  );
-}
-async function requestGuardException(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/exceptions/request",
-    {
-      method: "POST",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardExceptionListResponseSchema,
-    "guard exception request response"
-  );
-}
-async function syncGuardInventory(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/inventory/sync",
-    {
-      method: "POST",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardReceiptSyncResponseSchema,
-    "guard inventory sync response"
-  );
+  return dynamicImport(specifier);
 }
-async function removeGuardException(client, exceptionId) {
-  const normalizedExceptionId = exceptionId.trim();
-  if (!normalizedExceptionId) {
-    throw new Error("exceptionId is required");
+function optionalImportSync(specifier) {
+  if (isBrowser && !isNodeRuntime()) {
+    return null;
   }
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/exceptions/${encodeURIComponent(normalizedExceptionId)}`,
-    { method: "DELETE" }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardExceptionListResponseSchema,
-    "guard exceptions response"
-  );
-}
-async function getGuardTeamPolicyPack(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/team/policy-pack",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardTeamPolicyPackSchema,
-    "guard team policy pack response"
-  );
-}
-async function updateGuardTeamPolicyPack(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/team/policy-pack",
-    {
-      method: "PUT",
-      body: payload
+  try {
+    const requireFn = getNodeRequireSync();
+    if (requireFn) {
+      return requireFn(specifier);
     }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardTeamPolicyPackSchema,
-    "guard team policy pack response"
-  );
-}
-async function syncGuardReceipts(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/receipts/sync",
-    {
-      method: "POST",
-      body: payload
+  } catch (error) {
+    if (!isModuleNotFound(specifier, error)) {
+      throw error;
     }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardReceiptSyncResponseSchema,
-    "guard receipt sync response"
-  );
+  }
+  return null;
 }
 export {
-  addGuardException,
-  addGuardWatchlistItem,
-  exportGuardAbom,
-  exportGuardArtifactAbom,
-  exportGuardReceipts,
-  fetchGuardAdvisories,
-  fetchGuardPolicy,
-  getGuardAggregatedPainSignals,
-  getGuardAlertPreferences,
-  getGuardArtifactTimeline,
-  getGuardBillingBalance,
-  getGuardDevices,
-  getGuardEntitlements,
-  getGuardExceptions,
-  getGuardFeed,
-  getGuardInventory,
-  getGuardInventoryDiff,
-  getGuardOverview,
-  getGuardPainSignals,
-  getGuardPreExecutionVerdict,
-  getGuardPreInstallVerdict,
-  getGuardReceiptHistory,
-  getGuardRevocations,
-  getGuardSession,
-  getGuardTeamPolicyPack,
-  getGuardTrustByHash,
-  getGuardWatchlist,
-  ingestGuardPainSignals,
-  lookupGuardWatchlist,
-  removeGuardException,
-  removeGuardWatchlistItem,
-  requestGuardException,
-  resolveGuardTrust,
-  submitGuardReceipts,
-  syncGuardInventory,
-  syncGuardReceipts,
-  updateGuardAlertPreferences,
-  updateGuardTeamPolicyPack
+  optionalImport,
+  optionalImportSync
 };
 //# sourceMappingURL=standards-sdk.es186.js.map