@hashgraphonline/standards-sdk 0.1.179 → 0.1.181

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

@@ -1,188 +1,687 @@
-import { Buffer } from "buffer";
-import { ledgerChallengeResponseSchema, ledgerVerifyResponseSchema } from "./standards-sdk.es160.js";
-import { canonicalizeLedgerNetwork } from "./standards-sdk.es149.js";
-import { createPrivateKeySignerAsync } from "./standards-sdk.es148.js";
-async function loadViemAccount(privateKey) {
+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.es162.js";
+import { RegistryBrokerError } from "./standards-sdk.es146.js";
+function isStatusError(error) {
+  if (error instanceof RegistryBrokerError) {
+    return true;
+  }
+  if (typeof error !== "object" || error === null || !("status" in error)) {
+    return false;
+  }
+  return typeof Reflect.get(error, "status") === "number";
+}
+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;
+      }
+    }
+    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("/");
+    }
+  }
+  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;
+  }
+}
+async function requestPortalFirstJson(client, path, init) {
   try {
-    const viem = await import("viem/accounts");
-    return viem.privateKeyToAccount(privateKey);
+    return await client.requestJson(path, init);
   } catch (error) {
-    const err = new Error(
-      'EVM ledger authentication requires the optional dependency "viem". Install it to use evmPrivateKey flows.'
-    );
-    err.cause = error;
-    throw err;
-  }
-}
-async function resolveLedgerAuthSignature(message, options) {
-  if (typeof options.sign === "function") {
-    const result = await options.sign(message);
-    if (!result || typeof result.signature !== "string" || result.signature.length === 0) {
-      throw new Error("Custom ledger signer failed to produce a signature.");
-    }
-    return result;
-  }
-  if (!options.signer || typeof options.signer.sign !== "function") {
-    throw new Error(
-      "Ledger authentication requires a Hedera Signer or custom sign function."
-    );
-  }
-  const payload = Buffer.from(message, "utf8");
-  const signatures = await options.signer.sign([payload]);
-  const signatureEntry = signatures?.[0];
-  if (!signatureEntry) {
-    throw new Error("Signer did not return any signatures.");
-  }
-  let derivedPublicKey;
-  if (signatureEntry.publicKey) {
-    derivedPublicKey = signatureEntry.publicKey.toString();
-  } else if (typeof options.signer.getAccountKey === "function") {
-    const accountKey = await options.signer.getAccountKey();
-    if (accountKey && typeof accountKey.toString === "function") {
-      derivedPublicKey = accountKey.toString();
-    }
-  }
-  return {
-    signature: Buffer.from(signatureEntry.signature).toString("base64"),
-    signatureKind: "raw",
-    publicKey: derivedPublicKey
-  };
+    if (isStatusError(error) && (error.status === 404 || error.status === 501)) {
+      return client.requestAbsoluteJson(
+        buildPortalCanonicalGuardUrl(client.baseUrl, path),
+        init
+      );
+    }
+    throw error;
+  }
 }
-async function createLedgerChallenge(client, payload) {
-  const resolvedNetwork = canonicalizeLedgerNetwork(payload.network);
-  const network = resolvedNetwork.kind === "hedera" ? resolvedNetwork.hederaNetwork ?? resolvedNetwork.canonical : resolvedNetwork.canonical;
-  const raw = await client.requestJson("/auth/ledger/challenge", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: {
-      accountId: payload.accountId,
-      network
+async function getGuardSession(client) {
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/auth/session",
+    {
+      method: "GET"
     }
-  });
+  );
   return client.parseWithSchema(
     raw,
-    ledgerChallengeResponseSchema,
-    "ledger challenge response"
+    guardSessionResponseSchema,
+    "guard session response"
   );
 }
-async function verifyLedgerChallenge(client, payload) {
-  const resolvedNetwork = canonicalizeLedgerNetwork(payload.network);
-  const network = resolvedNetwork.kind === "hedera" ? resolvedNetwork.hederaNetwork ?? resolvedNetwork.canonical : resolvedNetwork.canonical;
-  const body = {
-    challengeId: payload.challengeId,
-    accountId: payload.accountId,
-    network,
-    signature: payload.signature
-  };
-  if (payload.signatureKind) {
-    body.signatureKind = payload.signatureKind;
+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)));
   }
-  if (payload.publicKey) {
-    body.publicKey = payload.publicKey;
+  const query = params.toString();
+  const suffix = query ? `?${query}` : "";
+  const raw = await requestPortalFirstJson(
+    client,
+    `/guard/feed${suffix}`,
+    {
+      method: "GET"
+    }
+  );
+  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"
+  );
+}
+async function resolveGuardTrust(client, query) {
+  const params = new URLSearchParams();
+  if (query.ecosystem?.trim()) {
+    params.set("ecosystem", query.ecosystem.trim());
   }
-  if (typeof payload.expiresInMinutes === "number") {
-    body.expiresInMinutes = payload.expiresInMinutes;
+  if (query.name?.trim()) {
+    params.set("name", query.name.trim());
   }
-  const raw = await client.requestJson("/auth/ledger/verify", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body
-  });
-  const result = client.parseWithSchema(
+  if (query.version?.trim()) {
+    params.set("version", query.version.trim());
+  }
+  const suffix = params.size > 0 ? `?${params.toString()}` : "";
+  const raw = await requestPortalFirstJson(
+    client,
+    `/guard/trust/resolve${suffix}`,
+    { method: "GET" }
+  );
+  return client.parseWithSchema(
     raw,
-    ledgerVerifyResponseSchema,
-    "ledger verification response"
+    guardTrustResolveResponseSchema,
+    "guard trust resolve response"
   );
-  client.setLedgerApiKey(result.key);
-  return result;
 }
-async function authenticateWithLedger(client, options) {
-  const challenge = await client.createLedgerChallenge({
-    accountId: options.accountId,
-    network: options.network
+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"
+  );
+}
+async function getGuardReceiptHistory(client) {
+  const raw = await requestPortalFirstJson(
+    client,
+    "/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 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"
   });
-  const signed = await resolveLedgerAuthSignature(challenge.message, options);
-  const verification = await client.verifyLedgerChallenge({
-    challengeId: challenge.challengeId,
-    accountId: options.accountId,
-    network: options.network,
-    signature: signed.signature,
-    signatureKind: signed.signatureKind,
-    publicKey: signed.publicKey,
-    expiresInMinutes: options.expiresInMinutes
+  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 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 verification;
-}
-async function authenticateWithLedgerCredentials(client, options) {
-  const {
-    accountId,
-    network,
-    signer,
-    sign,
-    hederaPrivateKey,
-    evmPrivateKey,
-    expiresInMinutes,
-    setAccountHeader = true,
-    label,
-    logger
-  } = options;
-  const resolvedNetwork = canonicalizeLedgerNetwork(network);
-  const labelSuffix = label ? ` for ${label}` : "";
-  const networkPayload = resolvedNetwork.canonical;
-  const authOptions = {
-    accountId,
-    network: networkPayload,
-    expiresInMinutes
-  };
-  if (sign) {
-    authOptions.sign = sign;
-  } else if (signer) {
-    authOptions.signer = signer;
-  } else if (hederaPrivateKey) {
-    if (resolvedNetwork.kind !== "hedera" || !resolvedNetwork.hederaNetwork) {
-      throw new Error(
-        "hederaPrivateKey can only be used with hedera:mainnet or hedera:testnet networks."
-      );
+  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 }
     }
-    authOptions.signer = await createPrivateKeySignerAsync({
-      accountId,
-      privateKey: hederaPrivateKey,
-      network: resolvedNetwork.hederaNetwork
-    });
-  } else if (evmPrivateKey) {
-    if (resolvedNetwork.kind !== "evm") {
-      throw new Error(
-        "evmPrivateKey can only be used with CAIP-2 EVM networks (eip155:<chainId>)."
-      );
+  );
+  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
     }
-    const formattedKey = evmPrivateKey.startsWith("0x") ? evmPrivateKey : `0x${evmPrivateKey}`;
-    const account = await loadViemAccount(formattedKey);
-    authOptions.sign = async (message) => ({
-      signature: await account.signMessage({ message }),
-      signatureKind: "evm",
-      publicKey: account.publicKey
-    });
-  } else {
-    throw new Error(
-      "Provide a signer, sign function, hederaPrivateKey, or evmPrivateKey to authenticate with the ledger."
-    );
+  );
+  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
+    }
+  );
+  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");
   }
-  logger?.info?.(
-    `Authenticating ledger account ${accountId} (${resolvedNetwork.canonical})${labelSuffix}...`
+  const raw = await requestPortalFirstJson(
+    client,
+    `/guard/watchlist/${encodeURIComponent(normalizedArtifactId)}`,
+    { method: "DELETE" }
+  );
+  return client.parseWithSchema(
+    raw,
+    guardWatchlistResponseSchema,
+    "guard watchlist response"
   );
-  const verification = await client.authenticateWithLedger(authOptions);
-  if (setAccountHeader) {
-    client.setDefaultHeader("x-account-id", verification.accountId);
+}
+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"
+  );
+}
+async function removeGuardException(client, exceptionId) {
+  const normalizedExceptionId = exceptionId.trim();
+  if (!normalizedExceptionId) {
+    throw new Error("exceptionId is required");
   }
-  logger?.info?.(
-    `Ledger authentication complete${labelSuffix}. Issued key prefix: ${verification.apiKey.prefix}…${verification.apiKey.lastFour}`
+  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
+    }
+  );
+  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
+    }
+  );
+  return client.parseWithSchema(
+    raw,
+    guardReceiptSyncResponseSchema,
+    "guard receipt sync response"
   );
-  return verification;
 }
 export {
-  authenticateWithLedger,
-  authenticateWithLedgerCredentials,
-  createLedgerChallenge,
-  verifyLedgerChallenge
+  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
 };
 //# sourceMappingURL=standards-sdk.es183.js.map