node-autotask 0.8.0 → 0.8.1

package/dist/{chunk-GNS47RBV.js → chunk-IUJJPWUX.js}

@@ -1,14 +1,560 @@
-import {
-  AutotaskConfigError,
-  AutotaskError,
-  HostPolicyDeniedError,
-  NoopLogger,
-  PaginationLimitError
-} from "./chunk-FE225M76.js";
-import {
-  CREDENTIAL_ENV_LOAD_ACTION,
-  credentialShapeProblem
-} from "./chunk-QF4K3XTK.js";
+// src/logger.ts
+var NoopLogger = {};
+var REDACTED = "[REDACTED]";
+var CREDENTIAL_HEADER_NAMES = [
+  "ApiIntegrationCode",
+  "UserName",
+  "Secret",
+  "ImpersonationResourceId",
+  "authToken"
+];
+function normalizeKey(key) {
+  return key.toLowerCase().replace(/[_-]/g, "");
+}
+var CREDENTIAL_KEY_SET = new Set(CREDENTIAL_HEADER_NAMES.map(normalizeKey));
+function isCredentialHeaderName(name, extraSecretKeys) {
+  const normalized = normalizeKey(name);
+  if (CREDENTIAL_KEY_SET.has(normalized)) return true;
+  if (extraSecretKeys === void 0) return false;
+  return extraSecretKeys.some((extra) => normalizeKey(extra) === normalized);
+}
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function redactRecord(value, extraSecretKeys) {
+  if (Array.isArray(value)) {
+    return value.map((item) => redactRecord(item, extraSecretKeys));
+  }
+  if (isPlainRecord(value)) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      out[key] = isCredentialHeaderName(key, extraSecretKeys) ? REDACTED : redactRecord(item, extraSecretKeys);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/redact.ts
+var SECRET_RESPONSE_FIELDS = [
+  "password",
+  // ClientPortalUserModel
+  "secretKey",
+  // the 5 webhook models
+  "secret"
+  // IntegrationVendorInsightModel, IntegrationVendorWidgetModel
+];
+var PERSONAL_RESPONSE_FIELDS = [
+  "additionalAddressInformation",
+  "additionalBillToAddressInformation",
+  "additionalShipToAddressInformation",
+  "address1",
+  "address2",
+  "addressLine",
+  "addressLine1",
+  "alternatePhone",
+  "alternatePhone1",
+  "alternatePhone2",
+  "billingAddress1",
+  "billingAddress2",
+  "billToAdditionalAddressInformation",
+  "billToCity",
+  "billToPostalCode",
+  "billToZipCode",
+  "city",
+  "email",
+  "email2",
+  "email3",
+  "emailAddress",
+  "emailAddress2",
+  "emailAddress3",
+  "extApprovalContactResponse",
+  "fax",
+  "faxNumber",
+  "gender",
+  "homePhone",
+  "mobilePhone",
+  "notificationEmailAddress",
+  "officePhone",
+  "phone",
+  "postalCode",
+  "recipientEmailAddress",
+  "rmmIsMobileDeviceManagementEnrolled",
+  "shipToAddress1",
+  "shipToAddress2",
+  "shipToCity",
+  "shipToPostalCode",
+  "userName",
+  "zipCode"
+];
+var CONFIDENTIAL_RESPONSE_FIELDS = [
+  "domain",
+  "domainExpirationDateTime",
+  "domainLastUpdatedDateTime",
+  "domainRegistrationDateTime",
+  "primaryContact",
+  "rmmDeviceAuditExternalIPAddress",
+  "rmmDeviceAuditIPAddress",
+  "rmmDeviceAuditMacAddress",
+  "rmmDeviceAuditMobileNumber",
+  "rmmDeviceAuditSNMPContact",
+  "taxID",
+  "webAddress"
+];
+var SECRET_SET = new Set(SECRET_RESPONSE_FIELDS);
+var OPTIONAL_SET = /* @__PURE__ */ new Set([...PERSONAL_RESPONSE_FIELDS, ...CONFIDENTIAL_RESPONSE_FIELDS]);
+function isPlainRecord2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isRedactedFieldName(name, policy) {
+  return SECRET_SET.has(name) || policy.redactPersonalData && OPTIONAL_SET.has(name);
+}
+function redactResponseBody(value, policy) {
+  const personal = policy.redactPersonalData;
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactResponseBody(entry, policy));
+  }
+  if (!isPlainRecord2(value)) return value;
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const pinned = SECRET_SET.has(key) || personal && OPTIONAL_SET.has(key);
+    out[key] = pinned ? REDACTED : redactResponseBody(entry, policy);
+  }
+  return out;
+}
+
+// src/errors.ts
+function isRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+var AutotaskError = class extends Error {
+  code;
+  category;
+  operation;
+  httpStatus;
+  vendorError;
+  resourceIds;
+  suggestedAction;
+  correlationId;
+  retryable;
+  url;
+  /** Issue #9/#14: the additive structured extras (recovery refusal payload; emptyReason / pointerNote) — never changes the error contract. */
+  details;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "AutotaskError";
+    this.code = options.code ?? "AUTOTASK_ERROR";
+    this.category = options.category ?? "server";
+    this.retryable = options.retryable ?? false;
+    this.operation = options.operation;
+    this.httpStatus = options.httpStatus;
+    this.vendorError = options.vendorError;
+    this.resourceIds = options.resourceIds;
+    this.suggestedAction = options.suggestedAction;
+    this.correlationId = options.correlationId;
+    this.url = options.url;
+    this.details = options.details;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+var AutotaskConfigError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "CONFIG_ERROR", category: "validation", ...options });
+    this.name = "AutotaskConfigError";
+  }
+};
+var AutotaskNetworkError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "NETWORK_ERROR",
+      category: "network",
+      retryable: true,
+      suggestedAction: options.suggestedAction ?? "Check connectivity to the Autotask zone and retry.",
+      ...options
+    });
+    this.name = "AutotaskNetworkError";
+  }
+};
+var AutotaskTimeoutError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "TIMEOUT",
+      category: "timeout",
+      retryable: true,
+      suggestedAction: options.suggestedAction ?? "Retry, narrow the query, or raise timeoutMs.",
+      ...options
+    });
+    this.name = "AutotaskTimeoutError";
+  }
+};
+var AutotaskAbortError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "ABORTED", category: "network", retryable: false, ...options });
+    this.name = "AutotaskAbortError";
+  }
+};
+var ResponseRejectedError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "RESPONSE_REJECTED", category: "policy", retryable: false, ...options });
+    this.name = "ResponseRejectedError";
+  }
+};
+var BadRequestError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "BAD_REQUEST", category: "validation", ...options });
+    this.name = "BadRequestError";
+  }
+};
+var UnauthorizedError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "UNAUTHORIZED", category: "auth", ...options });
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "FORBIDDEN", category: "auth", ...options });
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "NOT_FOUND", category: "not_found", ...options });
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "CONFLICT", category: "conflict", ...options });
+    this.name = "ConflictError";
+  }
+};
+var UnprocessableEntityError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "VALIDATION_FAILED", category: "validation", ...options });
+    this.name = "UnprocessableEntityError";
+  }
+};
+var RateLimitError = class extends AutotaskError {
+  /** Seconds the server asked the client to wait (`Retry-After`), when present. */
+  retryAfter;
+  /** True when the call was refused locally (the tenant cooldown gate) and never sent. */
+  notSent;
+  constructor(message, options = {}) {
+    super(message, { code: "RATE_LIMITED", category: "rate_limit", retryable: true, ...options });
+    this.name = "RateLimitError";
+  }
+};
+var ServerError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "SERVER_ERROR", category: "server", retryable: true, ...options });
+    this.name = "ServerError";
+  }
+};
+var UnexpectedContentTypeError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "UNEXPECTED_CONTENT_TYPE", category: "server", retryable: true, ...options });
+    this.name = "UnexpectedContentTypeError";
+  }
+};
+var EmptyResponseError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "EMPTY_RESPONSE", category: "server", ...options });
+    this.name = "EmptyResponseError";
+  }
+};
+var CircuitBreakerError = class extends AutotaskError {
+  /** Seconds remaining in the open period (absent when the half-open probe budget is in flight). */
+  retryAfter;
+  /** True when the call was refused locally (the circuit is open) and never sent. */
+  notSent;
+  constructor(message, options = {}) {
+    super(message, { code: "CIRCUIT_BREAKER_OPEN", category: "policy", retryable: true, ...options });
+    this.name = "CircuitBreakerError";
+  }
+};
+var HostPolicyDeniedError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "HOST_POLICY_DENIED", category: "policy", retryable: false, ...options });
+    this.name = "HostPolicyDeniedError";
+  }
+};
+var ResolutionError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: options.code === void 0 ? "RESOLUTION_AMBIGUOUS" : options.code,
+      category: "resolution",
+      ...options
+    });
+    this.name = "ResolutionError";
+  }
+};
+var PaginationLimitError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "PAGINATION_LIMIT",
+      category: "policy",
+      suggestedAction: options.suggestedAction ?? "Narrow the query with a tighter filter so the walk stays under the 1000-page limit.",
+      ...options
+    });
+    this.name = "PaginationLimitError";
+  }
+};
+var QueryTooLongError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "QUERY_TOO_LONG",
+      category: "policy",
+      suggestedAction: options.suggestedAction ?? 'Use the default POST query path (omit via: "get") for filters above the 2048-char GET cap.',
+      ...options
+    });
+    this.name = "QueryTooLongError";
+  }
+};
+var MISSING_REQUIRED_FIELD = /^Missing Required Field:\s*([A-Za-z_][A-Za-z0-9_]*)/;
+function parseVendorErrors(body) {
+  if (!isRecord(body) || !Array.isArray(body.errors)) return void 0;
+  const out = [];
+  for (const entry of body.errors) {
+    if (typeof entry === "string") {
+      const item2 = { message: entry };
+      const m = MISSING_REQUIRED_FIELD.exec(entry);
+      if (m) item2.field = m[1];
+      out.push(item2);
+      continue;
+    }
+    if (!isRecord(entry)) continue;
+    const item = {};
+    if (typeof entry.message === "string") item.message = entry.message;
+    if (typeof entry.field === "string") item.field = entry.field;
+    if (typeof entry.code === "string") item.code = entry.code;
+    if (item.message !== void 0 || item.field !== void 0 || item.code !== void 0) {
+      out.push(item);
+    }
+  }
+  return out;
+}
+var DETERMINISTIC_VENDOR_500_PHRASES = [/exceeds maximum length/i];
+function isDeterministicVendor500(entries) {
+  if (entries === void 0) return false;
+  return entries.some(
+    (entry) => entry.message !== void 0 && DETERMINISTIC_VENDOR_500_PHRASES.some((phrase) => phrase.test(entry.message))
+  );
+}
+function formatVendorEntry(entry) {
+  const parts = [];
+  if (entry.code) parts.push(`[${entry.code}]`);
+  if (entry.field) parts.push(`Field '${entry.field}':`);
+  if (entry.message) parts.push(entry.message);
+  return parts.join(" ");
+}
+function formatVendorDetail(body) {
+  const entries = parseVendorErrors(body);
+  if (entries && entries.length > 0) {
+    const formatted = entries.map(formatVendorEntry).filter((line) => line.length > 0);
+    if (formatted.length > 0) return formatted.join(" | ");
+  }
+  if (isRecord(body) && typeof body.message === "string" && body.message.trim().length > 0) {
+    return body.message.trim();
+  }
+  return void 0;
+}
+function isMachineCode(code) {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]{2,}$/.test(code) && /\d/.test(code);
+}
+function errorClassForStatus(status) {
+  switch (status) {
+    case 400:
+      return BadRequestError;
+    case 401:
+      return UnauthorizedError;
+    case 403:
+      return ForbiddenError;
+    case 404:
+      return NotFoundError;
+    case 409:
+    case 412:
+      return ConflictError;
+    case 422:
+      return UnprocessableEntityError;
+    case 429:
+      return RateLimitError;
+    default:
+      return status >= 500 && status < 600 ? ServerError : null;
+  }
+}
+function statusDefaultMessage(status) {
+  switch (status) {
+    case 401:
+      return "Authentication failed: Invalid credentials";
+    case 404:
+      return "Resource not found";
+    default:
+      return `Autotask API request failed with status ${status}`;
+  }
+}
+var VENDOR_BODY_SUFFIX_LIMIT = 200;
+function vendorBodySuffix(body) {
+  const rendered = typeof body === "string" ? body : JSON.stringify(body);
+  if (rendered === void 0 || rendered === "null" || rendered === "{}" || rendered === "[]") return void 0;
+  return rendered.length > VENDOR_BODY_SUFFIX_LIMIT ? rendered.slice(0, VENDOR_BODY_SUFFIX_LIMIT) : rendered;
+}
+var DIAGNOSTIC_SHAPE_ANOMALY = "sent value shows shell-quoting/line-break artifacts \u2014 check your env load";
+var DIAGNOSTIC_NO_ANOMALY = "sent value shows no shape anomalies \u2014 credentials or account state are the likely cause";
+var CREDENTIAL_SHAPE_POINTER = "Load the credential the way the file documents: shell-sourced (`set -a; . ./.env; set +a`) or via loadAutotaskCredentialsFromEnv() from node-autotask \u2014 a quote-preserving parser hands the value over with its quotes intact, which the vendor rejects as invalid credentials.";
+function credentialDiagnosticDetails(credential) {
+  if (credential === void 0) return void 0;
+  const diagnostic = credential.allValuesClean ? DIAGNOSTIC_NO_ANOMALY : `${DIAGNOSTIC_SHAPE_ANOMALY} (${credential.problem ?? "shape anomaly detected"})`;
+  return { diagnostic, pointerNote: CREDENTIAL_SHAPE_POINTER };
+}
+function mergeDetails(base, extra) {
+  if (base === void 0) return extra;
+  if (extra === void 0) return base;
+  return { ...base, ...extra };
+}
+function suggestedActionForStatus(status) {
+  switch (status) {
+    case 400:
+    case 422:
+      return "Fix the request payload; see the vendor error for the offending field.";
+    case 401:
+      return "Check the API integration code, username and secret (3-header auth).";
+    case 403:
+      return "Verify permissions; if ImpersonationResourceId is set, retry without it.";
+    case 404:
+      return "Verify the id, or resolve the record by name first.";
+    case 409:
+    case 412:
+      return "Re-read the record and retry with current values.";
+    case 429:
+      return "Back off and retry; honour Retry-After.";
+    default:
+      return status >= 500 ? "Retry with backoff; the server error is transient." : void 0;
+  }
+}
+function errorFromStatus(status, body, url, operation, redactPersonalData = true, credential) {
+  const safeBody = redactResponseBody(body, { redactPersonalData });
+  let detail = formatVendorDetail(safeBody);
+  if (detail !== void 0 && detail.length > VENDOR_BODY_SUFFIX_LIMIT) {
+    detail = detail.slice(0, VENDOR_BODY_SUFFIX_LIMIT);
+  }
+  const suffix = detail === void 0 ? vendorBodySuffix(safeBody) : void 0;
+  const message = detail ?? (suffix !== void 0 ? `${statusDefaultMessage(status)}: ${suffix}` : statusDefaultMessage(status));
+  const mapped = errorClassForStatus(status);
+  const Ctor = mapped ?? AutotaskError;
+  const code = mapped !== null ? defaultCodeForClass(mapped) : `HTTP_${status}`;
+  const entries = parseVendorErrors(safeBody);
+  const vendorCodeCandidate = (isRecord(safeBody) && typeof safeBody.code === "string" ? safeBody.code : void 0) ?? (entries?.[0]?.code ?? void 0);
+  const credentialDetails = status === 401 ? credentialDiagnosticDetails(credential) : void 0;
+  const extraDetails = mergeDetails(void 0, credentialDetails);
+  const err = new Ctor(message, {
+    code: vendorCodeCandidate !== void 0 && isMachineCode(vendorCodeCandidate) ? vendorCodeCandidate : code,
+    httpStatus: status,
+    vendorError: safeBody,
+    url,
+    operation,
+    retryable: status === 429 || status >= 500,
+    suggestedAction: suggestedActionForStatus(status),
+    ...extraDetails !== void 0 ? { details: extraDetails } : {}
+  });
+  if (Ctor === AutotaskError) err.name = "AutotaskError";
+  if (status >= 500 && isDeterministicVendor500(entries)) {
+    err.retryable = false;
+    err.details = mergeDetails(err.details, { deterministic: true });
+    const dot = operation !== void 0 ? operation.indexOf(".") : -1;
+    const resource = operation !== void 0 && dot > 0 ? operation.slice(0, dot) : void 0;
+    err.suggestedAction = "Deterministic field rejection \u2014 fix the value, do not retry. " + (resource !== void 0 ? `Consult ${resource}.getFieldInfo for the field catalog (types, required, maxLength).` : "Consult the resource's getFieldInfo for the field catalog (types, required, maxLength).");
+  }
+  return err;
+}
+var StaleObjectError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "STALE_OBJECT",
+      category: "conflict",
+      suggestedAction: "Re-read the record and retry with the fresh lastModifiedDate.",
+      ...options
+    });
+    this.name = "StaleObjectError";
+  }
+};
+var ConfirmationRequiredError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "CONFIRMATION_REQUIRED", category: "policy", ...options });
+    this.name = "ConfirmationRequiredError";
+  }
+};
+var DeleteBoundaryError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "DELETE_BOUNDARY", category: "policy", ...options });
+    this.name = "DeleteBoundaryError";
+  }
+};
+var MarkerUnsafeIdError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "MARKER_UNSAFE_ID", category: "policy", ...options });
+    this.name = "MarkerUnsafeIdError";
+  }
+};
+var RecoveryTruncatedError = class extends AutotaskError {
+  constructor(message, options = {}) {
+    super(message, { code: "RECOVERY_TRUNCATED", category: "policy", ...options });
+    this.name = "RecoveryTruncatedError";
+  }
+};
+function defaultCodeForClass(Ctor) {
+  switch (Ctor) {
+    case BadRequestError:
+      return "BAD_REQUEST";
+    case UnauthorizedError:
+      return "UNAUTHORIZED";
+    case ForbiddenError:
+      return "FORBIDDEN";
+    case NotFoundError:
+      return "NOT_FOUND";
+    case ConflictError:
+      return "CONFLICT";
+    case UnprocessableEntityError:
+      return "VALIDATION_FAILED";
+    case RateLimitError:
+      return "RATE_LIMITED";
+    default:
+      return "SERVER_ERROR";
+  }
+}
+function isAutotaskError(err) {
+  return err instanceof AutotaskError;
+}
+
+// src/credential-shape.ts
+var QUOTE_CHARS = /* @__PURE__ */ new Set(["'", '"']);
+function hasSurroundingQuotes(value) {
+  if (value.length < 2) return false;
+  const first = value[0];
+  return QUOTE_CHARS.has(first) && value[value.length - 1] === first;
+}
+function credentialShapeProblem(value, options = {}) {
+  if (!options.skipEdgeWhitespace) {
+    if (/^\s/.test(value)) return "leading whitespace";
+    if (/\s$/.test(value)) return "trailing whitespace";
+  }
+  if (!options.skipSurroundingQuotes && hasSurroundingQuotes(value)) {
+    return "single- or double-quote surrounding the value";
+  }
+  if (value.includes("\r")) return "carriage return";
+  return void 0;
+}
+var CREDENTIAL_ENV_LOAD_ACTION = "value appears shell-quoted or line-break contaminated \u2014 check how your env file was loaded (single-quoted values must be shell-sourced, not parsed by a quote-preserving loader)";
+var MIN_PREFIX_SUMMARY_LENGTH = 4;
+function credentialValueSummary(value) {
+  return value.length >= MIN_PREFIX_SUMMARY_LENGTH ? `len ${value.length}, starts "${value.slice(0, 2)}"` : "short value (length withheld)";
+}
 
 // src/fieldCache.ts
 var FIELD_CACHE_MAX_ENTITIES = 256;
@@ -838,11 +1384,11 @@ function resolveConfig(config) {
 
 // src/utils/index.ts
 import { randomUUID } from "crypto";
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function assertRecord(value, label) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     const got = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
     throw new AutotaskError(`Expected ${label} to be an object, got ${got}`, {
       code: "INVALID_RESPONSE",
@@ -853,7 +1399,7 @@ function assertRecord(value, label) {
   return value;
 }
 function isMergeable(value) {
-  return isRecord(value);
+  return isRecord2(value);
 }
 function deepMergeParams(base, override) {
   const out = { ...base };
@@ -887,7 +1433,7 @@ function flattenUdfs(record, options) {
   const udfs = record.userDefinedFields;
   if (!Array.isArray(udfs)) return out;
   for (const udf of udfs) {
-    if (!isRecord(udf) || typeof udf.name !== "string" || udf.name === "") continue;
+    if (!isRecord2(udf) || typeof udf.name !== "string" || udf.name === "") continue;
     const target = udf.name in out ? `${prefix}${udf.name}` : udf.name;
     if (!(target in out)) out[target] = udf.value;
   }
@@ -899,7 +1445,7 @@ function newCorrelationId() {
 var CREDENTIAL_KEY_RE = /(^|[_\-.])(secret|secrets|password|passwd|passphrase|token|tokens|apikey|api_key|apiintegrationcode|credentials?|accesskey|access_key|authcode|authorization)([_\-.]|$)|([A-Za-z0-9])(secrets?|tokens?|password|passwd|passphrase|credentials?|keys?|apiintegrationcode)(?=$)/i;
 function redactAuditBody(value) {
   if (Array.isArray(value)) return value.map((entry) => redactAuditBody(entry));
-  if (!isRecord(value)) return value;
+  if (!isRecord2(value)) return value;
   const out = {};
   for (const [key, entry] of Object.entries(value)) {
     out[key] = CREDENTIAL_KEY_RE.test(key) ? "[REDACTED]" : redactAuditBody(entry);
@@ -12850,6 +13396,54 @@ var CREATE_GUIDANCE = {
 };
 
 export {
+  NoopLogger,
+  REDACTED,
+  CREDENTIAL_HEADER_NAMES,
+  isCredentialHeaderName,
+  redactRecord,
+  SECRET_RESPONSE_FIELDS,
+  PERSONAL_RESPONSE_FIELDS,
+  CONFIDENTIAL_RESPONSE_FIELDS,
+  isRedactedFieldName,
+  redactResponseBody,
+  AutotaskError,
+  AutotaskConfigError,
+  AutotaskNetworkError,
+  AutotaskTimeoutError,
+  AutotaskAbortError,
+  ResponseRejectedError,
+  BadRequestError,
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  ConflictError,
+  UnprocessableEntityError,
+  RateLimitError,
+  ServerError,
+  UnexpectedContentTypeError,
+  EmptyResponseError,
+  CircuitBreakerError,
+  HostPolicyDeniedError,
+  ResolutionError,
+  PaginationLimitError,
+  QueryTooLongError,
+  parseVendorErrors,
+  isDeterministicVendor500,
+  formatVendorDetail,
+  CREDENTIAL_SHAPE_POINTER,
+  mergeDetails,
+  errorFromStatus,
+  StaleObjectError,
+  ConfirmationRequiredError,
+  DeleteBoundaryError,
+  MarkerUnsafeIdError,
+  RecoveryTruncatedError,
+  isAutotaskError,
+  hasSurroundingQuotes,
+  credentialShapeProblem,
+  CREDENTIAL_ENV_LOAD_ACTION,
+  MIN_PREFIX_SUMMARY_LENGTH,
+  credentialValueSummary,
   FIELD_CACHE_KINDS,
   DEFAULT_CIRCUIT_BREAKER_WINDOW_MS,
   DEFAULT_CIRCUIT_BREAKER_FAILURE_THRESHOLD,
@@ -12885,7 +13479,7 @@ export {
   zoneUrl,
   resolveBaseUrl,
   resolveConfig,
-  isRecord,
+  isRecord2 as isRecord,
   assertRecord,
   deepMergeParams,
   parseIdentifier,
@@ -12912,4 +13506,4 @@ export {
   collectAll,
   toArray
 };
-//# sourceMappingURL=chunk-GNS47RBV.js.map
+//# sourceMappingURL=chunk-IUJJPWUX.js.map