@hashgraphonline/standards-sdk 0.1.184 → 0.1.185

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

@@ -1,242 +1,687 @@
-const DEFAULT_USER_AGENT = "@hol-org/rb-client";
-const DEFAULT_PROGRESS_INTERVAL_MS = 1500;
-const DEFAULT_PROGRESS_TIMEOUT_MS = 5 * 60 * 1e3;
-const DEFAULT_BASE_URL = "https://hol.org/registry/api/v1";
-const JSON_CONTENT_TYPE = /application\/json/i;
-const DEFAULT_HISTORY_TOP_UP_HBAR = 0.25;
-const MINIMUM_REGISTRATION_AUTO_TOP_UP_CREDITS = 1;
-const stripTrailingSlashes = (value) => {
-  let end = value.length;
-  while (end > 0 && value.charCodeAt(end - 1) === 47) {
-    end -= 1;
-  }
-  return end === value.length ? value : value.slice(0, end);
-};
-const createAbortError = () => typeof DOMException === "function" ? new DOMException("Aborted", "AbortError") : new Error("The operation was aborted");
-const normaliseHeaderName = (name) => name.trim().toLowerCase();
-const isBrowserRuntime = () => typeof window !== "undefined" && typeof window.fetch === "function";
-const toJsonValue = (value) => {
-  if (value === null) {
-    return null;
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => item === void 0 ? null : toJsonValue(item));
-  }
-  if (typeof value === "object") {
-    const result = {};
-    Object.entries(value).forEach(
-      ([key, entryValue]) => {
-        if (entryValue !== void 0) {
-          result[key] = toJsonValue(entryValue);
-        }
-      }
-    );
-    return result;
-  }
-  throw new TypeError("Only JSON-compatible values are supported");
-};
-const isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const toJsonObject = (value) => {
-  const normalised = toJsonValue(value);
-  if (isJsonObject(normalised)) {
-    return normalised;
-  }
-  throw new TypeError("Expected JSON object value");
-};
-const serialiseAuthConfig = (auth) => {
-  const authPayload = {};
-  if (auth.type) {
-    authPayload.type = auth.type;
-  }
-  if (auth.token) {
-    authPayload.token = auth.token;
+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;
   }
-  if (auth.username) {
-    authPayload.username = auth.username;
+  if (typeof error !== "object" || error === null || !("status" in error)) {
+    return false;
   }
-  if (auth.password) {
-    authPayload.password = auth.password;
-  }
-  if (auth.headerName) {
-    authPayload.headerName = auth.headerName;
-  }
-  if (auth.headerValue) {
-    authPayload.headerValue = auth.headerValue;
-  }
-  if (auth.headers) {
-    authPayload.headers = { ...auth.headers };
-  }
-  return authPayload;
-};
-const serialiseAgentRegistrationRequest = (payload) => {
-  const body = {
-    profile: toJsonObject(payload.profile)
+  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;
   };
-  if (payload.endpoint !== void 0) {
-    body.endpoint = payload.endpoint;
-  }
-  if (payload.protocol !== void 0) {
-    body.protocol = payload.protocol;
-  }
-  if (payload.communicationProtocol !== void 0) {
-    body.communicationProtocol = payload.communicationProtocol;
-  }
-  if (payload.registry !== void 0) {
-    body.registry = payload.registry;
-  }
-  if (payload.additionalRegistries !== void 0) {
-    body.additionalRegistries = payload.additionalRegistries;
-  }
-  if (payload.metadata !== void 0) {
-    body.metadata = toJsonObject(payload.metadata);
-  }
-  return body;
-};
-const normalizeHexPrivateKey = (value) => {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    throw new Error("evmPrivateKey is required");
+  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 trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
-};
-function normaliseBaseUrl(input) {
-  const trimmed = input?.trim();
-  let baseCandidate = trimmed && trimmed.length > 0 ? trimmed : DEFAULT_BASE_URL;
-  try {
-    const url = new URL(stripTrailingSlashes(baseCandidate));
-    const hostname = url.hostname.toLowerCase();
-    const ensureRegistryPrefix = () => {
-      if (!url.pathname.startsWith("/registry")) {
-        url.pathname = url.pathname === "/" ? "/registry" : `/registry${url.pathname}`;
-      }
-    };
-    if (hostname === "hol.org") {
-      ensureRegistryPrefix();
-      baseCandidate = url.toString();
-    } else if (hostname === "registry.hashgraphonline.com" || hostname === "hashgraphonline.com") {
-      ensureRegistryPrefix();
-      url.hostname = "hol.org";
-      baseCandidate = url.toString();
+  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;
   }
-  const withoutTrailing = stripTrailingSlashes(baseCandidate);
-  if (/\/api\/v\d+$/i.test(withoutTrailing)) {
-    return withoutTrailing;
-  }
-  if (/\/api$/i.test(withoutTrailing)) {
-    return `${withoutTrailing}/v1`;
+}
+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;
   }
-  return `${withoutTrailing}/api/v1`;
 }
-function buildSearchQuery(params) {
-  const query = new URLSearchParams();
-  const appendList = (key, values) => {
-    if (!values) {
-      return;
+async function getGuardSession(client) {
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/auth/session",
+    {
+      method: "GET"
     }
-    values.forEach((value) => {
-      if (typeof value === "string") {
-        const trimmed = value.trim();
-        if (trimmed.length > 0) {
-          query.append(key, trimmed);
-        }
-      }
-    });
-  };
-  if (params.q) {
-    const trimmed = params.q.trim();
-    if (trimmed.length > 0) {
-      query.set("q", trimmed);
+  );
+  return client.parseWithSchema(
+    raw,
+    guardSessionResponseSchema,
+    "guard session response"
+  );
+}
+async function getGuardEntitlements(client) {
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/entitlements",
+    {
+      method: "GET"
     }
-  }
-  if (typeof params.page === "number") {
-    query.set("page", params.page.toString());
-  }
-  if (typeof params.limit === "number") {
-    query.set("limit", params.limit.toString());
-  }
-  if (params.registry) {
-    const trimmed = params.registry.trim();
-    if (trimmed.length > 0) {
-      query.set("registry", trimmed);
+  );
+  return client.parseWithSchema(
+    raw,
+    guardSessionResponseSchema,
+    "guard entitlements response"
+  );
+}
+async function getGuardBillingBalance(client) {
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/billing/balance",
+    {
+      method: "GET"
     }
-  }
-  appendList("registries", params.registries);
-  if (typeof params.minTrust === "number") {
-    query.set("minTrust", params.minTrust.toString());
-  }
-  appendList("capabilities", params.capabilities);
-  appendList("protocols", params.protocols);
-  appendList("adapters", params.adapters);
-  if (params.metadata) {
-    Object.entries(params.metadata).forEach(([key, values]) => {
-      if (!key || !Array.isArray(values) || values.length === 0) {
-        return;
-      }
-      const trimmedKey = key.trim();
-      if (trimmedKey.length === 0) {
-        return;
-      }
-      values.forEach((value) => {
-        if (value === void 0 || value === null) {
-          return;
-        }
-        query.append(`metadata.${trimmedKey}`, String(value));
-      });
-    });
-  }
-  if (params.type) {
-    const trimmedType = params.type.trim();
-    if (trimmedType.length > 0 && trimmedType.toLowerCase() !== "all") {
-      query.set("type", trimmedType);
+  );
+  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"
     }
-  }
-  if (params.verified === true) {
-    query.set("verified", "true");
-  }
-  if (params.online === true) {
-    query.set("online", "true");
-  }
-  if (params.sortBy) {
-    const trimmedSort = params.sortBy.trim();
-    if (trimmedSort.length > 0) {
-      query.set("sortBy", trimmedSort);
+  );
+  return client.parseWithSchema(
+    raw,
+    guardFeedResponseSchema,
+    "guard feed response"
+  );
+}
+async function getGuardOverview(client) {
+  const raw = await requestPortalFirstJson(
+    client,
+    "/guard/overview",
+    {
+      method: "GET"
     }
-  }
-  if (params.sortOrder) {
-    const lowered = params.sortOrder.toLowerCase();
-    if (lowered === "asc" || lowered === "desc") {
-      query.set("sortOrder", lowered);
+  );
+  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"
     }
-  }
-  const queryString = query.toString();
-  return queryString.length > 0 ? `?${queryString}` : "";
+  );
+  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 {
-  DEFAULT_BASE_URL,
-  DEFAULT_HISTORY_TOP_UP_HBAR,
-  DEFAULT_PROGRESS_INTERVAL_MS,
-  DEFAULT_PROGRESS_TIMEOUT_MS,
-  DEFAULT_USER_AGENT,
-  JSON_CONTENT_TYPE,
-  MINIMUM_REGISTRATION_AUTO_TOP_UP_CREDITS,
-  buildSearchQuery,
-  createAbortError,
-  isBrowserRuntime,
-  isJsonObject,
-  normaliseBaseUrl,
-  normaliseHeaderName,
-  normalizeHexPrivateKey,
-  serialiseAgentRegistrationRequest,
-  serialiseAuthConfig,
-  toJsonObject,
-  toJsonValue
+  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.es186.js.map