@hashgraphonline/standards-sdk 0.1.189 → 0.1.191

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

@@ -0,0 +1,687 @@
+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.es178.js";
+import { RegistryBrokerError } from "./standards-sdk.es171.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 {
+    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;
+  }
+}
+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 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 (query.name?.trim()) {
+    params.set("name", query.name.trim());
+  }
+  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,
+    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"
+  );
+}
+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"
+  });
+  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 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
+    }
+  );
+  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"
+  );
+}
+async function removeGuardException(client, exceptionId) {
+  const normalizedExceptionId = exceptionId.trim();
+  if (!normalizedExceptionId) {
+    throw new Error("exceptionId is required");
+  }
+  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"
+  );
+}
+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
+};
+//# sourceMappingURL=standards-sdk.es228.js.map