woodsportal-client-sdk 1.1.5-dev.0 → 2.0.705

package/dist/chunk-BXHEEGBF.js

@@ -0,0 +1,2747 @@
+import { getParamDetails, getRouteDetails, updateLink, getParam, decodeToBase64, generatePath, getPath, getRouteMenu, tableUiActions, ticketHubspotObjectTypeId, makePreviewParams, tableStore, actions2, userStore, isPipelineBoardObjectTypeId, tableUiStore, fileStore, actions7, emailStore, actions5, noteStore, actions4, resetAllStore, breadcrumbStage, isMessingParentLastItem, isMessingParent, generateUrl } from './chunk-JSXP2F2H.js';
+import { getRuntimeHttpClientApiDate, config, configureLogger, setIframeStorageMode, setRefreshBufferSeconds, setRefreshCallback, hydrateSessionRefreshState, logger, isHttpTracingEnabled, getAccessToken, sanitizeAxiosErrorData, classifyRefreshHttpError, shouldLogoutAfterRefreshFailure, setRefreshToken, storAccessToken, classifyRefreshResponseWithoutToken, storage, HUBSPOT_DATA, setRuntimeHttpClientHubContext, isServiceUnavailableError, refreshSession, ensureValidRefresh, HUB_ID, DEV_PORTAL_ID, PORTAL_ID, DEV_API_URL, isAccessTokenExpired } from './chunk-XDYXEYDM.js';
+import { getClientType, configureStorageKeys } from './chunk-32ERSTFY.js';
+import { AuthErrorCode } from './chunk-COHBSTHF.js';
+import axios from 'axios';
+
+// src/main/core/utils/generateApiUrl.ts
+var API_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+function shouldSkipApiDate(url) {
+  if (!url.startsWith("/api/")) return true;
+  if (url.startsWith("/api/platform/")) return true;
+  if (url.startsWith("/api/public-app/")) return true;
+  if (url.startsWith("/api/webhooks/")) return true;
+  if (url.startsWith("/api/internal/")) return true;
+  return false;
+}
+function alreadyHasApiDate(url) {
+  if (url.startsWith("/api/admin/")) {
+    return /^\/api\/admin\/\d{4}-\d{2}-\d{2}(?:\/|$)/.test(url);
+  }
+  return /^\/api\/\d{4}-\d{2}-\d{2}(?:\/|$)/.test(url);
+}
+function applyContractApiDate(url, apiDate) {
+  const date = (apiDate ?? "").trim();
+  if (!date || !API_DATE_RE.test(date)) return url;
+  if (shouldSkipApiDate(url) || alreadyHasApiDate(url)) return url;
+  if (url.startsWith("/api/admin/")) {
+    return url.replace("/api/admin/", `/api/admin/${date}/`);
+  }
+  if (url.startsWith("/api/")) {
+    return url.replace("/api/", `/api/${date}/`);
+  }
+  return url;
+}
+function getConfiguredContractApiDate() {
+  return (getRuntimeHttpClientApiDate() || "").trim();
+}
+var generateApiUrl = ({ route, params = {}, queryParams = "" }) => {
+  const defaultParams = {
+    hubId: config.hubId,
+    portalId: config.portalId
+  };
+  params = { ...defaultParams, ...params };
+  const url = applyContractApiDate(replaceParams(route, params), getConfiguredContractApiDate());
+  let queryString = "";
+  if (queryParams && typeof queryParams === "object") {
+    const cleanedParams = Object.entries(queryParams).filter(([_, value]) => value !== null && value !== void 0).reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+    queryString = new URLSearchParams(cleanedParams).toString();
+  }
+  return queryString ? `${url}?${queryString}` : url;
+};
+function replaceParams(template, values) {
+  return template.replace(/\$\{(\w+)\}/g, (_, key) => key in values ? String(values[key]) : `\${${key}}`);
+}
+
+// src/main/core/http/visibility-refresh-scheduler.ts
+var visibilityStop = null;
+function hasBrowserDocument() {
+  return typeof document !== "undefined" && document != null;
+}
+function startVisibilityRefreshScheduler(options) {
+  if (getClientType() === "mobile") {
+    return () => void 0;
+  }
+  if (typeof window === "undefined" || !hasBrowserDocument()) {
+    return () => void 0;
+  }
+  visibilityStop?.();
+  const intervalMs = options.intervalMs ?? 6e4;
+  const tick = () => {
+    if (document.visibilityState !== "visible") return;
+    if (!options.shouldRefresh()) return;
+    void options.refresh();
+  };
+  const onVisibility = () => {
+    if (document.visibilityState === "visible") {
+      void tick();
+    }
+  };
+  const intervalId = window.setInterval(tick, intervalMs);
+  document.addEventListener("visibilitychange", onVisibility);
+  window.addEventListener("focus", onVisibility);
+  const stop = () => {
+    window.clearInterval(intervalId);
+    document.removeEventListener("visibilitychange", onVisibility);
+    window.removeEventListener("focus", onVisibility);
+    if (visibilityStop === stop) {
+      visibilityStop = null;
+    }
+  };
+  visibilityStop = stop;
+  return stop;
+}
+function stopVisibilityRefreshScheduler() {
+  visibilityStop?.();
+}
+
+// src/main/core/http/editor-preview-mock.ts
+var editorPreviewMockHandler = null;
+function setEditorPreviewMockHandler(handler) {
+  editorPreviewMockHandler = handler;
+}
+function isEditorPreviewMockActive() {
+  return editorPreviewMockHandler != null;
+}
+async function resolveEditorPreviewMock(config4) {
+  if (!editorPreviewMockHandler) {
+    return null;
+  }
+  return editorPreviewMockHandler(config4);
+}
+
+// src/main/core/http/api-endpoints.ts
+var API_ENDPOINTS = {
+  // Auth
+  PRE_LOGIN: "/api/auth/pre-login",
+  LOGIN: "/api/auth/login",
+  AUTH_REFRESH: "/api/auth/refresh",
+  AUTH_REFRESH_COOKIE: "/api/auth/refresh-cookie",
+  FORGET_PASSWORD: "/api/auth/forget-password",
+  FORGET_PASSWORD_OTP_VERIFY: "/api/auth/forget-password/otp/verify",
+  RESET_PASSWORD_VERIFY_TOKEN: "/api/auth/token/validate",
+  RESET_PASSWORD: "/api/auth/reset-password",
+  VERIFY_EMAIL: "/api/auth/verify-email",
+  REGISTER_EXISTING_USER: "/api/auth/existing-user-register",
+  RESEND_EMAIL: "/api/auth/resend-email",
+  VERIFY_EMAIL_RESEND: "/api/auth/verify-email/resend",
+  LOGOUT: "/api/auth/logout",
+  VERIFY_OTP: "/api/auth/verify-otp",
+  CLIENT_SESSION: "/api/auth/client-session",
+  AUTH_HANDOFF: "/api/auth/handoff",
+  SIGN_IN_LINK_SEND: "/api/auth/sign-in-link/send",
+  SIGN_IN_LINK_VERIFY: "/api/auth/sign-in-link/verify",
+  SIGN_IN_LINK_VALIDATE: "/api/auth/sign-in-link/validate",
+  // Auth MFA (client lane)
+  MFA_PENDING_OTP_SEND: "/api/auth/mfa/pending/otp/send",
+  MFA_PENDING_PASSKEY_OPTIONS: "/api/auth/mfa/pending/passkey/authenticate/options",
+  MFA_PENDING_PASSKEY_VERIFY: "/api/auth/mfa/pending/passkey/authenticate/verify",
+  MFA_STATUS: "/api/auth/mfa/status",
+  MFA_PREFERENCES: "/api/auth/mfa/preferences",
+  MFA_PHONE_VERIFY_START: "/api/auth/mfa/phone/verify/start",
+  MFA_PHONE_VERIFY_CONFIRM: "/api/auth/mfa/phone/verify/confirm",
+  MFA_PHONE_UNVERIFY: "/api/auth/mfa/phone/unverify",
+  MFA_BACKUP_CODES_REGENERATE: "/api/auth/mfa/backup-codes/regenerate",
+  MFA_OPT_OUT: "/api/auth/mfa/opt-out",
+  MFA_TOTP_ENROLL_START: "/api/auth/mfa/totp/enroll/start",
+  MFA_TOTP_ENROLL_VERIFY: "/api/auth/mfa/totp/enroll/verify",
+  MFA_TOTP_DISABLE: "/api/auth/mfa/totp/disable",
+  MFA_WEBAUTHN_REGISTER_OPTIONS: "/api/auth/mfa/webauthn/register/options",
+  MFA_WEBAUTHN_REGISTER_VERIFY: "/api/auth/mfa/webauthn/register/verify",
+  MFA_WEBAUTHN_AUTH_OPTIONS: "/api/auth/mfa/webauthn/authenticate/options",
+  MFA_WEBAUTHN_AUTH_VERIFY: "/api/auth/mfa/webauthn/authenticate/verify",
+  MFA_WEBAUTHN_CREDENTIALS: "/api/auth/mfa/webauthn/credentials",
+  MFA_WEBAUTHN_CREDENTIAL_DELETE: "/api/auth/mfa/webauthn/credentials/${credentialRecordId}",
+  PASSKEY_LOGIN_OPTIONS: "/api/auth/passkey/login/options",
+  PASSKEY_LOGIN_VERIFY: "/api/auth/passkey/login/verify",
+  // Auth Security (client lane)
+  SECURITY_OVERVIEW: "/api/auth/security/overview",
+  SECURITY_LOGIN_ACTIVITY: "/api/auth/security/login-activity",
+  SECURITY_SESSIONS: "/api/auth/security/sessions",
+  SECURITY_SESSION_REVOKE: "/api/auth/security/sessions/${familyId}/revoke",
+  SECURITY_SESSIONS_REVOKE_OTHERS: "/api/auth/security/sessions/revoke-others",
+  // Login bootstrap (portal MFA policy + SSO providers)
+  LOGIN_BOOTSTRAP: "/api/auth/login/bootstrap",
+  // SSO
+  SSO_DETAILS: "/api/auth/sso/active",
+  SSO_URL: "/api/auth/sso/authorize",
+  SSO_CALLBACK: "/api/auth/sso/callback",
+  // User
+  ME: "/api/${hubId}/${portalId}/auth/me?include=crmProfile",
+  PROFILE: "/api/${hubId}/${portalId}/profiles",
+  PROFILE_UPDATE: "/api/${hubId}/${portalId}/profiles",
+  CHANGE_PASSWORD: "/api/auth/change-password",
+  // Notification preferences (portal client — same row as admin prefs)
+  NOTIFICATION_PREFERENCES: "/api/${hubId}/${portalId}/notification-preferences",
+  // Accounts (client lane — hub / portal picker)
+  HUBSPOTS: "/api/hubspots",
+  PORTALS: "/api/portals",
+  // Mobile
+  MOBILE_NAVIGATION: "/api/${hubId}/${portalId}/mobile/navigation",
+  MOBILE_APP_CONFIG: "/api/${hubId}/${portalId}/mobile/app-config",
+  MOBILE_NAVIGATION_IMPORT_WEB_MENU: "/api/${hubId}/${portalId}/mobile/navigation/import-web-menu",
+  // Pipeline
+  PIPELINES: "/api/${hubId}/${portalId}/hubspot-object-pipelines/${hubspotObjectTypeId}",
+  // Stage
+  STAGES: "/api/${hubId}/${portalId}/hubspot-object-pipelines/${objectTypeId}/${pipelineId}/stages",
+  // Cache purge (replaces cache=false refresh; requires features.cache-purge-api-enabled on API)
+  CACHE_PURGE: "/api/${hubId}/${portalId}/cache-purge-jobs",
+  CACHE_PURGE_STATUS: "/api/${hubId}/${portalId}/cache-purge-jobs/${purgeJobId}",
+  /** @deprecated Use CACHE_PURGE */
+  CACHE_PURGE_LEGACY: "/api/${hubId}/${portalId}/cache/purge",
+  /** @deprecated Use CACHE_PURGE_STATUS */
+  CACHE_PURGE_STATUS_LEGACY: "/api/${hubId}/${portalId}/cache/purge/${purgeJobId}",
+  // Object (read on hubspot-object-data; form layout on hubspot-object-forms)
+  OBJECTS: "/api/${hubId}/${portalId}/hubspot-object-data/${hubspotObjectTypeId}/records",
+  OBJECTS_PUBLIC: "/api/${hubId}/public/hubspot-object-data/${hubspotObjectTypeId}/records",
+  OBJECTS_FORM: "/api/${hubId}/${portalId}/hubspot-object-forms/${hubspotObjectTypeId}/fields",
+  OBJECTS_FORM_OPTIONS: "/api/${hubId}/${portalId}/hubspot-object-forms/${formId}/${objectTypeId}",
+  RECORDS_CREATE: "/api/${hubId}/${portalId}/hubspot-object-data/${hubspotObjectTypeId}/records",
+  RECORDS_UPDATE: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}",
+  RECORDS_ASSOCIATE: "/api/${hubId}/${portalId}/hubspot-object-data/${fromObjectTypeId}/records/${fromRecordId}/associations/${toObjectTypeId}",
+  RECORDS_DISASSOCIATE: "/api/${hubId}/${portalId}/hubspot-object-data/${fromObjectTypeId}/records/${fromRecordId}/associations/${toObjectTypeId}",
+  RECORDS_EXISTING: "/api/${hubId}/${portalId}/hubspot-object-data/${hubspotObjectTypeId}/existing-records",
+  RECORDS_ADD_EXISTING: "/api/${hubId}/${portalId}/hubspot-object-data/${parentObjectTypeId}/records/${recordId}/associations/${hubspotObjectTypeId}",
+  /** @deprecated Use RECORDS_CREATE */
+  OBJECTS_CREATE: "/api/${hubId}/${portalId}/hubspot-object-forms/${hubspotObjectTypeId}/fields",
+  /** @deprecated Use RECORDS_ASSOCIATE */
+  OBJECTS_CREATE_EXISTING: "/api/${hubId}/${portalId}/hubspot-object-forms/:fromObjectTypeId/:fromRecordId/associations/:toObjectTypeId",
+  OBJECTS_DETAILS: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}",
+  OBJECTS_DETAILS_PUBLIC: "/api/${hubId}/public/hubspot-object-data/${objectId}/records/${id}",
+  /** @deprecated Use RECORDS_UPDATE */
+  OBJECTS_DETAILS_UPDATE: "/api/${hubId}/${portalId}/hubspot-object-forms/${objectId}/records/${id}",
+  OBJECTS_DETAILS_UPDATE_LEGACY: "/api/${hubId}/${portalId}/hubspot-object-forms/${objectId}/properties/${id}",
+  // Notes (nested under CRM record)
+  NOTES: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/notes",
+  NOTES_CREATE: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/notes",
+  NOTES_DETAILS_UPDATE: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/notes/${note_id}",
+  NOTES_IMAGE_UPLOAD: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/notes/images",
+  NOTES_ATTACHMENT_UPLOAD: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/notes/attachments",
+  NOTES_ATTACHMENT_UPDATE: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/notes/attachments/${note_id}",
+  // Email (nested under CRM record)
+  EMAILS: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/emails",
+  EMAILS_CREATE: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/emails",
+  EMAILS_DETAILS_UPDATE: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/emails/${email_id}",
+  EMAILS_IMAGE_UPLOAD: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/emails/images",
+  EMAILS_ATTACHMENT_UPLOAD: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/emails/attachments",
+  EMAILS_ATTACHMENT_UPDATE: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/emails/attachments/${email_id}",
+  // File manager (nested under CRM record)
+  FILES: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/files",
+  FILE: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/files/${rowId}",
+  FILE_DOWNLOAD: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/files/${rowId}/download",
+  FILES_CREATE_FOLDER: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/folders",
+  FILES_UPLOAD: "/api/${hubId}/${portalId}/hubspot-object-data/${objectId}/records/${id}/files"
+};
+
+// src/main/core/http/http-config.ts
+var config2 = {
+  baseURL: ""
+};
+
+// src/main/core/logging/log-http.ts
+var SENSITIVE_QUERY_KEYS = /* @__PURE__ */ new Set([
+  "token",
+  "refreshtoken",
+  "accesstoken",
+  "password",
+  "secret",
+  "authorization",
+  "otp",
+  "code",
+  "api_key",
+  "apikey"
+]);
+function isSensitiveQueryKey(key) {
+  const normalized = key.toLowerCase();
+  return SENSITIVE_QUERY_KEYS.has(normalized) || normalized.includes("password") || normalized.includes("token");
+}
+function resolveUrlBase() {
+  if (typeof window === "undefined") {
+    return "http://localhost";
+  }
+  try {
+    const origin = window.location?.origin;
+    if (typeof origin === "string" && origin.length > 0) {
+      return origin;
+    }
+  } catch {
+  }
+  return "http://localhost";
+}
+function sanitizeHttpUrl(url) {
+  if (url == null || url === "") {
+    return url;
+  }
+  try {
+    const base = resolveUrlBase();
+    const parsed = url.startsWith("http") ? new URL(url) : new URL(url, base);
+    for (const key of [...parsed.searchParams.keys()]) {
+      if (isSensitiveQueryKey(key)) {
+        parsed.searchParams.set(key, "[redacted]");
+      }
+    }
+    return url.startsWith("http") ? parsed.toString() : `${parsed.pathname}${parsed.search}${parsed.hash}`;
+  } catch {
+    return url;
+  }
+}
+var SDK_HTTP_TIMING_KEY = "__woodsportalSdkRequestStartMs";
+function markHttpRequestStart(config4) {
+  config4[SDK_HTTP_TIMING_KEY] = Date.now();
+}
+function getHttpRequestDurationMs(config4) {
+  const start = config4[SDK_HTTP_TIMING_KEY];
+  return typeof start === "number" ? Date.now() - start : void 0;
+}
+function getHttpMethod(config4) {
+  return config4.method?.toUpperCase();
+}
+function getHttpUrl(config4) {
+  return sanitizeHttpUrl(config4.url);
+}
+
+// src/main/core/http/csp-violation-monitor.ts
+var VIOLATION_TTL_MS = 3e4;
+var MAX_RECORDED = 20;
+var violations = [];
+var installed = false;
+function installCspViolationMonitor() {
+  if (installed || typeof document === "undefined" || typeof document.addEventListener !== "function") {
+    return;
+  }
+  installed = true;
+  document.addEventListener("securitypolicyviolation", (event) => {
+    violations.push({
+      blockedUri: event.blockedURI ?? "",
+      effectiveDirective: event.effectiveDirective ?? event.violatedDirective ?? "",
+      at: Date.now()
+    });
+    if (violations.length > MAX_RECORDED) {
+      violations = violations.slice(-MAX_RECORDED);
+    }
+  });
+}
+function findCspViolationFor(requestUrl) {
+  if (!requestUrl) {
+    return void 0;
+  }
+  const now = Date.now();
+  violations = violations.filter((violation) => now - violation.at <= VIOLATION_TTL_MS);
+  let origin;
+  try {
+    origin = new URL(requestUrl, typeof location !== "undefined" ? location.href : void 0).origin;
+  } catch {
+    return void 0;
+  }
+  return violations.find(
+    (violation) => violation.blockedUri === origin || violation.blockedUri.startsWith(`${origin}/`)
+  );
+}
+
+// src/main/core/http/http-client.ts
+var INVALID_PATH_SEGMENT_PATTERN = /\/(undefined|null|NaN)([/?#]|$)/;
+var axiosInstance = null;
+var config3 = {};
+function hasBrowserLocation() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  try {
+    return window.location != null;
+  } catch {
+    return false;
+  }
+}
+function buildAuthPolicy() {
+  const routes = config3.routes ?? {};
+  const base = config3.authPolicy ?? {};
+  return {
+    routes: {
+      unauthorized: routes.unauthorized ?? "/unauthorized",
+      login: routes.login ?? "/login",
+      twoFa: routes.twoFa ?? "/login/two-fa",
+      resendEmail: routes.resendEmail ?? "/resend-email",
+      accountSelect: routes.accountSelect ?? "/account-select",
+      ...base.routes
+    },
+    optionalAuthFailurePaths: base.optionalAuthFailurePaths ?? [
+      API_ENDPOINTS.LOGOUT,
+      API_ENDPOINTS.MFA_STATUS,
+      API_ENDPOINTS.MFA_PREFERENCES,
+      API_ENDPOINTS.MFA_TOTP_ENROLL_START,
+      API_ENDPOINTS.MFA_TOTP_ENROLL_VERIFY,
+      API_ENDPOINTS.MFA_TOTP_DISABLE,
+      API_ENDPOINTS.MFA_PHONE_VERIFY_START,
+      API_ENDPOINTS.MFA_PHONE_VERIFY_CONFIRM,
+      API_ENDPOINTS.MFA_WEBAUTHN_REGISTER_OPTIONS,
+      API_ENDPOINTS.MFA_WEBAUTHN_REGISTER_VERIFY,
+      API_ENDPOINTS.MFA_WEBAUTHN_CREDENTIALS
+    ],
+    sessionProbePaths: base.sessionProbePaths,
+    includeAdminMfaSecurityPrefixes: base.includeAdminMfaSecurityPrefixes ?? true
+  };
+}
+function formatUnauthorizedRoute(route) {
+  if (route.startsWith("#")) {
+    return route;
+  }
+  if (hasBrowserLocation() && window.location.hash.startsWith("#/")) {
+    return `#${route.startsWith("/") ? route : `/${route}`}`;
+  }
+  return route;
+}
+function isRecoverableSessionExpiredCode(errorCode) {
+  return errorCode === AuthErrorCode.TOKEN_EXPIRED || errorCode === AuthErrorCode.TOKEN_INVALID || errorCode === AuthErrorCode.AUTHENTICATION_FAILED || errorCode === AuthErrorCode.MISSING_REFRESH_TOKEN || errorCode === AuthErrorCode.ACCESS_UNAUTHORIZED;
+}
+function formatLoginRouteWithReturn(loginRoute) {
+  const loginPath = loginRoute.startsWith("/") ? loginRoute : `/${loginRoute}`;
+  if (!hasBrowserLocation()) {
+    return formatUnauthorizedRoute(loginPath);
+  }
+  const returnPath = window.location.hash.replace(/^#/, "") || window.location.pathname;
+  if (!returnPath || returnPath.startsWith("/login")) {
+    return formatUnauthorizedRoute(loginPath);
+  }
+  return formatUnauthorizedRoute(`${loginPath}?r=${encodeURIComponent(returnPath)}`);
+}
+function setBearerAuthorization(requestConfig, token) {
+  if (!requestConfig.headers) {
+    requestConfig.headers = {};
+  }
+  if (typeof requestConfig.headers.set === "function") {
+    requestConfig.headers.set("Authorization", `Bearer ${token}`);
+    return;
+  }
+  requestConfig.headers.Authorization = `Bearer ${token}`;
+}
+async function handleAuthHttpError(error, axiosInstanceRef) {
+  if (!error.response || !error.config) {
+    return Promise.reject(error);
+  }
+  const status = error.response.status;
+  if (status !== 401 && status !== 403) {
+    return Promise.reject(error);
+  }
+  const shouldHandleOnPublicPath = config3.skipCurrentPublicPath?.() ?? false;
+  const allowUnauthorizedHandling = config3.shouldHandleUnauthorized?.() ?? true;
+  if (!shouldHandleOnPublicPath || !allowUnauthorizedHandling) {
+    return Promise.reject(error);
+  }
+  const { parseApiErrorPayload } = await import('./auth-error-codes-D7CXVBEN.js');
+  const { persistAuthError, resolveAuthErrorAction } = await import('./auth-interceptor-policy-K46P4VM4.js');
+  const reqConfig = error.config;
+  const payload = parseApiErrorPayload(error.response.data);
+  const action = resolveAuthErrorAction({
+    status,
+    errorCode: payload.errorCode,
+    url: reqConfig.url,
+    skipGlobalAuthRedirect: reqConfig.skipGlobalAuthRedirect,
+    isRetryRequest: reqConfig.__isRetryRequest,
+    policy: buildAuthPolicy()
+  });
+  if (action.kind === "reject") {
+    return Promise.reject(error);
+  }
+  if (action.kind === "refresh_retry") {
+    if (isRefreshCallbackInFlight()) {
+      return Promise.reject(error);
+    }
+    try {
+      await refreshSession({ force: true });
+    } catch {
+    }
+    const token = getAccessToken();
+    if (token) {
+      const newConfig = { ...reqConfig, __isRetryRequest: true };
+      setBearerAuthorization(newConfig, token);
+      return axiosInstanceRef.request(newConfig);
+    }
+    persistAuthError(payload);
+    void config3.onLogout?.();
+    const policy = buildAuthPolicy();
+    const destination = isRecoverableSessionExpiredCode(payload.errorCode) ? formatLoginRouteWithReturn(policy.routes.login) : formatUnauthorizedRoute(policy.routes.unauthorized);
+    if (hasBrowserLocation()) {
+      window.location.replace(destination);
+    }
+    return Promise.reject(error);
+  }
+  persistAuthError(payload);
+  if (action.kind === "logout" || action.kind === "redirect") {
+    if (action.clearSession) {
+      void config3.onLogout?.();
+    }
+    if (hasBrowserLocation()) {
+      window.location.replace(formatUnauthorizedRoute(action.route));
+    }
+  }
+  return Promise.reject(error);
+}
+function persistHubContextFromClientConfig(clientConfig) {
+  const existing = storage.get(HUBSPOT_DATA) || {};
+  const next = { ...existing };
+  if (clientConfig.hubId != null && String(clientConfig.hubId).trim() !== "") {
+    next[HUB_ID] = String(clientConfig.hubId);
+  }
+  if (clientConfig.devPortalId != null && String(clientConfig.devPortalId).trim() !== "") {
+    const portalId = String(clientConfig.devPortalId);
+    next[DEV_PORTAL_ID] = portalId;
+    next[PORTAL_ID] = portalId;
+  } else {
+    delete next[DEV_PORTAL_ID];
+  }
+  if (clientConfig.baseURL) {
+    next[DEV_API_URL] = clientConfig.baseURL;
+  }
+  storage.set(HUBSPOT_DATA, next);
+  setRuntimeHttpClientHubContext({
+    hubId: clientConfig.hubId != null ? String(clientConfig.hubId) : "",
+    devPortalId: clientConfig.devPortalId != null ? String(clientConfig.devPortalId) : "",
+    devApiUrl: clientConfig.baseURL ?? "",
+    apiDate: clientConfig.apiDate != null ? String(clientConfig.apiDate).trim() : ""
+  });
+}
+function notifyServiceUnavailable(error) {
+  if (!isServiceUnavailableError(error)) return;
+  config3.onServiceUnavailable?.(error);
+}
+function initializeHttpClient(clientConfig) {
+  config3 = clientConfig;
+  persistHubContextFromClientConfig(clientConfig);
+  if (clientConfig.logger != null) {
+    configureLogger(clientConfig.logger);
+  }
+  if (clientConfig.storageKeys != null) {
+    configureStorageKeys(clientConfig.storageKeys);
+  }
+  void import('./storage-migration-CWOS6CNV.js').then(({ migrateLegacyStorageKeys }) => {
+    migrateLegacyStorageKeys();
+  }).catch(() => {
+  });
+  void import('./cross-tab-session-FCAQTXUB.js').then(({ installCrossTabSessionListener }) => {
+    installCrossTabSessionListener();
+  }).catch(() => {
+  });
+  setIframeStorageMode(clientConfig.storageMode === "iframe");
+  if (typeof clientConfig.refreshBufferSeconds === "number") {
+    setRefreshBufferSeconds(clientConfig.refreshBufferSeconds);
+  }
+  if (clientConfig.editorPreviewMockHandler !== void 0) {
+    setEditorPreviewMockHandler(clientConfig.editorPreviewMockHandler);
+  }
+  const baseURL = config?.devApiUrl || config3.baseURL;
+  if (!baseURL) {
+    throw new Error("WoodsPortal SDK HTTP client is not configured. Call initializeHttpClient({ baseURL }) at app startup.");
+  }
+  const timeout = config3.timeout ?? 5e4;
+  axiosInstance = axios.create({
+    baseURL,
+    timeout,
+    headers: {
+      "Content-Type": "application/json",
+      ...config3.headers
+    }
+  });
+  installCspViolationMonitor();
+  setRefreshCallback(getAuthRefreshToken);
+  hydrateSessionRefreshState();
+  axiosInstance.interceptors.request.use(async (requestConfig) => {
+    const requestUrl = getHttpUrl(requestConfig);
+    if (requestUrl && INVALID_PATH_SEGMENT_PATTERN.test(requestUrl)) {
+      logger.error("http", "blocked request with unresolved id in path", { url: requestUrl });
+      throw new Error(
+        `[woodsportal-sdk] Blocked request: URL contains an unresolved id segment: ${requestUrl}`
+      );
+    }
+    const previewMock = await resolveEditorPreviewMock(requestConfig);
+    if (previewMock) {
+      requestConfig.adapter = () => Promise.resolve({
+        data: previewMock.data,
+        status: previewMock.status ?? 200,
+        statusText: "OK",
+        headers: {},
+        config: requestConfig
+      });
+    }
+    markHttpRequestStart(requestConfig);
+    if (isHttpTracingEnabled()) {
+      logger.debug("http", "request start", {
+        method: getHttpMethod(requestConfig),
+        url: getHttpUrl(requestConfig),
+        phase: "start"
+      });
+    }
+    const token = getAccessToken();
+    if (token) {
+      setBearerAuthorization(requestConfig, token);
+    }
+    return requestConfig;
+  });
+  axiosInstance.interceptors.response.use(
+    (response) => {
+      if (isHttpTracingEnabled()) {
+        logger.debug("http", "request complete", {
+          method: getHttpMethod(response.config),
+          url: getHttpUrl(response.config),
+          status: response.status,
+          durationMs: getHttpRequestDurationMs(response.config),
+          phase: "complete"
+        });
+      }
+      return response;
+    },
+    (error) => {
+      if (axios.isAxiosError(error) && error.config) {
+        const status = error.response?.status;
+        if (status == null) {
+          const violation = findCspViolationFor(getHttpUrl(error.config));
+          if (violation) {
+            logger.error("http", "request blocked by the embedding page CSP", {
+              url: sanitizeHttpUrl(error.config.url),
+              violatedDirective: violation.effectiveDirective,
+              blockedUri: violation.blockedUri,
+              fix: `the embedding page's Content-Security-Policy must include "${violation.effectiveDirective} ${violation.blockedUri}"`
+            });
+          }
+        }
+        if (isHttpTracingEnabled()) {
+          logger.debug("http", "request failed", {
+            method: getHttpMethod(error.config),
+            url: getHttpUrl(error.config),
+            status,
+            durationMs: getHttpRequestDurationMs(error.config),
+            phase: "complete"
+          });
+        }
+        if (status != null && status >= 400 && status !== 401 && status !== 403) {
+          logger.warn("http", "HTTP error response", {
+            method: getHttpMethod(error.config),
+            url: sanitizeHttpUrl(error.config.url),
+            status,
+            statusText: error.response?.statusText,
+            data: sanitizeAxiosErrorData(error.response?.data)
+          });
+        }
+        notifyServiceUnavailable(error);
+      }
+      return handleAuthHttpError(error, axiosInstance);
+    }
+  );
+  stopVisibilityRefreshScheduler();
+  startVisibilityRefreshScheduler({
+    shouldRefresh: () => !isEditorPreviewMockActive() && isAccessTokenExpired(),
+    refresh: async () => {
+      try {
+        await refreshSession();
+      } catch {
+      }
+    }
+  });
+  logger.info("http", "HTTP client initialized", { baseURL });
+}
+function getAxiosInstance() {
+  if (!axiosInstance) {
+    initializeHttpClient({
+      baseURL: config2.baseURL,
+      timeout: 5e4
+    });
+  }
+  return axiosInstance;
+}
+function formatBooleanSearchParam(key, value) {
+  return value ? `${key}:1` : `${key}:`;
+}
+async function maybeEnsureValidRefresh() {
+  if (isEditorPreviewMockActive()) {
+    return;
+  }
+  await ensureValidRefresh();
+}
+var HttpClient = class {
+  static async get(url, params, options) {
+    await maybeEnsureValidRefresh();
+    const response = await getAxiosInstance().get(url, { params, ...options || {} });
+    return response.data;
+  }
+  static async post(url, data, options) {
+    await maybeEnsureValidRefresh();
+    const response = await getAxiosInstance().post(url, data, options);
+    return response.data;
+  }
+  static async put(url, data) {
+    await maybeEnsureValidRefresh();
+    const response = await getAxiosInstance().put(url, data);
+    return response.data;
+  }
+  static async delete(url, config4) {
+    await maybeEnsureValidRefresh();
+    const response = await getAxiosInstance().delete(url, config4);
+    return response.data;
+  }
+  static formatSearchParams(params) {
+    return Object.entries(params).filter(([, value]) => Boolean(value)).map(
+      ([k, v]) => ["type", "categories", "tags", "author", "manufacturer", "shops", "refund_reason"].includes(k) ? `${k}.slug:${v}` : ["is_approved"].includes(k) ? formatBooleanSearchParam(k, v) : `${k}:${v}`
+    ).join(";");
+  }
+};
+function mergeAuthRequestOptions(options) {
+  const devPortalId = config.devPortalId;
+  if (!devPortalId && !options?.headers) {
+    return options;
+  }
+  return {
+    ...options,
+    headers: {
+      ...devPortalId ? { "X-Dev-Portal-Id": devPortalId } : {},
+      ...options?.headers
+    }
+  };
+}
+var AuthHttpClient = class {
+  static async get(url, params, options) {
+    const response = await getAxiosInstance().get(url, { params, ...mergeAuthRequestOptions(options) });
+    return response.data;
+  }
+  static async post(url, data, options) {
+    const response = await getAxiosInstance().post(url, data, options);
+    return response.data;
+  }
+  static async put(url, data, options) {
+    const response = await getAxiosInstance().put(url, data, options);
+    return response.data;
+  }
+};
+function getFormErrors(error) {
+  if (axios.isAxiosError(error)) {
+    return error.response?.data?.message ?? null;
+  }
+  return null;
+}
+function getFieldErrors(error) {
+  if (axios.isAxiosError(error)) {
+    return error.response?.data?.errors ?? null;
+  }
+  return null;
+}
+async function postRefreshCookie(headers) {
+  const apiUrl = generateApiUrl({
+    route: API_ENDPOINTS.AUTH_REFRESH_COOKIE,
+    queryParams: { hubId: config.hubId }
+  });
+  return getAxiosInstance().post(apiUrl, {}, {
+    headers,
+    withCredentials: true,
+    skipGlobalAuthRedirect: true
+  });
+}
+var refreshCallbackInFlight = false;
+function isRefreshCallbackInFlight() {
+  return refreshCallbackInFlight;
+}
+function clearSessionAfterRefreshFailure() {
+  if (isEditorPreviewMockActive()) {
+    return;
+  }
+  if (config3.shouldHandleUnauthorized?.() === false) {
+    return;
+  }
+  void config3.onLogout?.();
+}
+async function getAuthRefreshToken(refreshToken) {
+  refreshCallbackInFlight = true;
+  try {
+    const hubId = config.hubId;
+    if (hubId == null || String(hubId).trim() === "") {
+      return { token: null, success: false, failureKind: "missing_context" };
+    }
+    if (refreshToken == null || refreshToken.trim() === "") {
+      return { token: null, success: false, failureKind: "missing_refresh_token" };
+    }
+    const headers = {};
+    if (config.devPortalId) {
+      headers["X-Dev-Portal-Id"] = config.devPortalId;
+    }
+    let response;
+    if (config3.useCookieRefresh) {
+      try {
+        response = await postRefreshCookie(headers);
+      } catch {
+        const apiUrl = generateApiUrl({
+          route: API_ENDPOINTS.AUTH_REFRESH,
+          queryParams: { hubId: config.hubId }
+        });
+        try {
+          response = await getAxiosInstance().post(apiUrl, { refreshToken }, {
+            headers,
+            skipGlobalAuthRedirect: true
+          });
+        } catch (bodyError) {
+          const failureKind2 = classifyRefreshHttpError(bodyError);
+          if (shouldLogoutAfterRefreshFailure(failureKind2)) {
+            clearSessionAfterRefreshFailure();
+          }
+          if (failureKind2 === "transient") {
+            notifyServiceUnavailable(bodyError);
+            logger.warn("auth", bodyError instanceof Error ? bodyError.message : "token refresh failed", {
+              operation: "token refresh",
+              failureKind: failureKind2
+            });
+          } else {
+            logger.error("auth", bodyError instanceof Error ? bodyError.message : "token refresh failed", {
+              operation: "token refresh",
+              failureKind: failureKind2
+            });
+          }
+          return { token: null, success: false, failureKind: failureKind2, cause: bodyError };
+        }
+      }
+    } else {
+      const apiUrl = generateApiUrl({
+        route: API_ENDPOINTS.AUTH_REFRESH,
+        queryParams: { hubId: config.hubId }
+      });
+      try {
+        response = await getAxiosInstance().post(apiUrl, { refreshToken }, {
+          headers,
+          skipGlobalAuthRedirect: true
+        });
+      } catch (error) {
+        const failureKind2 = classifyRefreshHttpError(error);
+        if (shouldLogoutAfterRefreshFailure(failureKind2)) {
+          clearSessionAfterRefreshFailure();
+        }
+        if (failureKind2 === "transient") {
+          notifyServiceUnavailable(error);
+          logger.warn("auth", error instanceof Error ? error.message : "token refresh failed", {
+            operation: "token refresh",
+            failureKind: failureKind2
+          });
+        } else {
+          logger.error("auth", error instanceof Error ? error.message : "token refresh failed", {
+            operation: "token refresh",
+            failureKind: failureKind2
+          });
+        }
+        return { token: null, success: false, failureKind: failureKind2, cause: error };
+      }
+    }
+    const maybeData = response?.data?.data || response?.data;
+    const tokenData = maybeData?.tokenData || maybeData || {};
+    const newRefreshToken = tokenData?.refreshToken;
+    const token = tokenData?.token;
+    const expiresIn = tokenData?.expiresIn;
+    const rExpiresIn = tokenData?.refreshExpiresIn;
+    const rExpiresAt = tokenData?.refreshExpiresAt;
+    if (typeof newRefreshToken === "string") {
+      let rExpires = 0;
+      if (typeof rExpiresIn === "number") {
+        rExpires = Date.now() + rExpiresIn * 1e3;
+      } else if (typeof rExpiresAt === "number") {
+        rExpires = rExpiresAt * 1e3;
+      }
+      setRefreshToken(newRefreshToken, rExpires);
+    }
+    if (typeof token === "string") {
+      storAccessToken(token, typeof expiresIn === "number" ? expiresIn : void 0);
+      return { token, success: true };
+    }
+    const failureKind = classifyRefreshResponseWithoutToken(response);
+    if (shouldLogoutAfterRefreshFailure(failureKind)) {
+      clearSessionAfterRefreshFailure();
+      logger.error("auth", "refresh response missing access token", {
+        operation: "token refresh",
+        failureKind
+      });
+    } else {
+      logger.warn("auth", "refresh response missing access token", {
+        operation: "token refresh",
+        failureKind
+      });
+    }
+    return { token: null, success: false, failureKind };
+  } finally {
+    refreshCallbackInFlight = false;
+  }
+}
+
+// src/main/features/navigation/breadcrumbs.ts
+var getBreadcrumbs = () => {
+  const search = getParam("b");
+  const breadcrumbs = decodeToBase64(search) || [];
+  if (!breadcrumbs && breadcrumbs.length < 1) return [];
+  const updated = breadcrumbs.map((breadcrumb, index) => {
+    return generatePath(breadcrumbs, breadcrumb, index);
+  });
+  if (updated.length < 1) {
+    const pathname = getPath();
+    const routeMenu = getRouteMenu(pathname);
+    return [
+      {
+        name: routeMenu?.title,
+        path: routeMenu?.path
+      }
+    ];
+  }
+  return updated;
+};
+var getTableTitle = (componentName, title, ticketTableTitle) => {
+  const search = getParam("b");
+  let breadcrumbs = decodeToBase64(search) || [];
+  if (breadcrumbs.length < 1) {
+    const pathname = getPath();
+    const routeMenu = getRouteMenu(pathname);
+    breadcrumbs = [
+      {
+        n: routeMenu?.title,
+        pt: routeMenu?.path
+      }
+    ];
+  }
+  let associatedtableTitleSingular = "";
+  let tableTitle = "";
+  let singularTableTitle = "";
+  if (breadcrumbs && breadcrumbs.length > 0) {
+    const lastItem = breadcrumbs[breadcrumbs.length - 1];
+    const last = lastItem ? generatePath(breadcrumbs, lastItem, breadcrumbs.length - 1) : null;
+    const previousItem = breadcrumbs[breadcrumbs.length - 2];
+    const previous = previousItem ? generatePath(breadcrumbs, previousItem, breadcrumbs.length - 2) : null;
+    const singularLastName = last?.name;
+    associatedtableTitleSingular = singularLastName;
+    if (componentName != "ticket") {
+      tableTitle = previous?.name ? { last, previous } : { last };
+      singularTableTitle = previous?.name ? `${singularLastName} with ${previous?.name}` : singularLastName;
+    } else {
+      const ticketTableTitleSingular = ticketTableTitle.endsWith("s") ? ticketTableTitle.slice(0, -1) : ticketTableTitle;
+      tableTitle = { last: { name: title } };
+      singularTableTitle = previous?.name ? `${ticketTableTitleSingular} with ${singularLastName} ` : ticketTableTitleSingular;
+    }
+  }
+  return { associatedtableTitleSingular, tableTitle, singularTableTitle };
+};
+var getFormTitle = (type, title, activeTab) => {
+  const search = getParam("b");
+  let breadcrumbs = decodeToBase64(search) || [];
+  if (breadcrumbs.length < 1) {
+    const pathname = getPath();
+    const routeMenu = getRouteMenu(pathname);
+    breadcrumbs = [
+      {
+        n: routeMenu?.title,
+        pt: routeMenu?.path
+      }
+    ];
+  }
+  let objectName = "";
+  let puralObjectName = "";
+  let dialogTitle = "";
+  if (breadcrumbs && breadcrumbs?.length > 0) {
+    const last = breadcrumbs[breadcrumbs?.length - 1];
+    const lastName = last?.n;
+    const mTitle = title;
+    if (type === "association" && breadcrumbs && breadcrumbs?.length > 0) {
+      objectName = title;
+      puralObjectName = title;
+      dialogTitle = `${activeTab == "addNew" ? `Create a new ${mTitle} for ${nameTrancate(lastName)}` : `Associate an Existing ${mTitle} with ${nameTrancate(lastName)}`}`;
+    } else {
+      const singularLastName = typeof lastName === "string" && lastName?.endsWith("s") ? lastName.slice(0, -1) : lastName;
+      objectName = singularLastName;
+      puralObjectName = lastName;
+      dialogTitle = `${activeTab == "addNew" ? `Create a new ${mTitle?.includes("with") ? nameTrancate(mTitle?.replace("with", "for")) : nameTrancate(mTitle)}` : `Associate an Existing ${nameTrancate(mTitle)}`}`;
+    }
+  }
+  return { objectName, puralObjectName, dialogTitle };
+};
+var nameTrancate = (name) => {
+  return name?.length > 30 ? `${name?.slice(0, 30) + "..."}` : name;
+};
+
+// src/main/features/navigation/generate-url.ts
+var makeLink = () => {
+  const search = getParam("b");
+  const makeLink2 = (props) => {
+    if (!search || "isPC" in props) {
+      return buildParentRoute(props);
+    } else {
+      const breadcrumbItems = decodeToBase64(search) || [];
+      return buildChildRoute(props, breadcrumbItems);
+    }
+  };
+  return { makeLink: makeLink2 };
+};
+var buildParentRoute = (props) => {
+  const pathname = getPath();
+  const routeMenu = getRouteMenu(pathname);
+  const breadcrumbItems = [
+    {
+      n: routeMenu?.title,
+      o_t_id: routeMenu?.path,
+      isHome: props?.isHome || false
+    }
+  ];
+  return buildChildRoute(props, breadcrumbItems);
+};
+var buildChildRoute = (props, breadcrumbItems) => {
+  const breadcrumbs = [...breadcrumbItems];
+  const breadcrumbType = breadcrumbStage(breadcrumbItems);
+  if (props?.isHome && isMessingParentLastItem(breadcrumbItems)) {
+    const parent = {
+      n: props?.title || "",
+      o_t_id: props?.objectTypeId,
+      pt: `/association/${props?.objectTypeId}`,
+      isHome: props?.isHome || false,
+      prm: {
+        sort: "-hs_createdate",
+        s: "",
+        fPn: "hs_pipeline",
+        fO: "eq",
+        fV: "",
+        c: true,
+        isPC: props?.isPC,
+        v: "LIST",
+        l: "10",
+        p: 1
+      }
+    };
+    breadcrumbs.push(parent);
+    const newCrumb = {
+      n: props?.name,
+      o_t_id: props?.objectTypeId,
+      o_r_id: props?.recordId
+    };
+    if (props?.nodeId) {
+      newCrumb.n_id = props.nodeId;
+    }
+    breadcrumbs.push(newCrumb);
+  } else if (breadcrumbType === "root") {
+    const newCrumb = {
+      n: props?.name,
+      o_t_id: props?.objectTypeId,
+      o_r_id: props?.recordId
+    };
+    if (props?.nodeId) {
+      newCrumb.n_id = props.nodeId;
+    }
+    if (props?.isPC) {
+      newCrumb.prm = {
+        isPC: props?.isPC
+      };
+    }
+    breadcrumbs.push(newCrumb);
+  } else {
+    const lastItem = breadcrumbs[breadcrumbs.length - 1];
+    if (props?.objectTypeId != "0-5" && breadcrumbs.length > 2 && // check for only association ticket object
+    !isMessingParent(breadcrumbItems) && lastItem?.o_t_id === props?.objectTypeId && // check for all associated object and check isMessingParent for skip parent to child  and child to parent association data
+    props?.isHome && !isMessingParentLastItem(breadcrumbItems)) {
+      const newCrumb = {
+        n: props?.name,
+        o_t_id: props?.objectTypeId,
+        o_r_id: props?.recordId
+      };
+      if (props?.nodeId) {
+        newCrumb.n_id = props.nodeId;
+      }
+      if (props?.isPC) {
+        newCrumb.prm = {
+          isPC: props?.isPC
+        };
+      }
+      breadcrumbs.push(newCrumb);
+    } else {
+      const lastItem2 = breadcrumbs[breadcrumbs.length - 1];
+      const parent = {
+        n: props?.associationLabel || props?.name,
+        o_t_id: props?.objectTypeId
+      };
+      if (props?.tableParam) {
+        parent.prm = props?.tableParam;
+      }
+      if (props?.defPermissions) {
+        parent.dp = props?.defPermissions;
+      }
+      if (lastItem2?.o_t_id && lastItem2?.o_r_id) {
+        breadcrumbs.push(parent);
+      }
+      if (props?.recordId) {
+        const newCrumb = {
+          n: props?.name,
+          o_t_id: props?.objectTypeId,
+          o_r_id: props?.recordId
+        };
+        if (props?.isPC) {
+          newCrumb.prm = {
+            isPC: props?.isPC
+          };
+        }
+        breadcrumbs.push(newCrumb);
+      }
+    }
+  }
+  return generateUrl(props, breadcrumbs);
+};
+
+// src/main/api/navigation-api.ts
+var navigationApi = {
+  url: {
+    makeLink,
+    updateLink
+  },
+  route: {
+    getDetails: getRouteDetails,
+    getParamDetails
+  },
+  breadcrumbs: {
+    getList: getBreadcrumbs,
+    getTableTitle,
+    getFormTitle
+  }
+};
+
+// src/main/core/utils/cache/builders.ts
+function buildCrmListPurgeTarget(objectTypeId, listQuery, recordIds) {
+  const target = {
+    domain: "crm_object_data",
+    objectTypeId,
+    views: ["list"],
+    listQuery: listQuery ?? { page: 1, limit: 10, view: "LIST" }
+  };
+  if (recordIds?.length) {
+    target.recordIds = recordIds;
+  }
+  return target;
+}
+function buildCrmSinglePurgeTarget(objectTypeId, recordIds, listQuery) {
+  return {
+    domain: "crm_object_data",
+    objectTypeId,
+    views: ["single"],
+    recordIds,
+    listQuery
+  };
+}
+function buildEngagementPurgeTarget(objectTypeId, recordIds, views, options) {
+  if (!recordIds.length) {
+    throw new Error("recordIds is required for engagement purge views");
+  }
+  const target = {
+    domain: "crm_object_data",
+    objectTypeId,
+    recordIds,
+    views,
+    fileIds: options?.fileIds,
+    listQuery: options?.listQuery ?? { page: 1, limit: 10 }
+  };
+  if (options?.engagementItemIds?.length) {
+    target.engagementItemIds = options.engagementItemIds;
+  }
+  return target;
+}
+function buildUserSessionPurgeTarget() {
+  return { domain: "user_session" };
+}
+function buildPortalConfigPurgeTarget(objectTypeIds) {
+  return {
+    domain: "portal_object_config",
+    objectTypeIds
+  };
+}
+function mergePurgeTargets(...targets) {
+  return targets;
+}
+function buildCachePurgeRequest(targets, options) {
+  const request = {
+    mode: options?.mode ?? "soft",
+    warm: options?.warm ?? true,
+    includeContactAccess: options?.includeContactAccess ?? true,
+    includeShortOnHard: options?.includeShortOnHard ?? false,
+    confirmPortalWide: options?.confirmPortalWide ?? false,
+    targets
+  };
+  if (options?.postCrmWrite) {
+    request.postCrmWrite = true;
+  }
+  if (options?.warmListDelayMs != null) {
+    request.warmListDelayMs = options.warmListDelayMs;
+  }
+  return request;
+}
+
+// src/main/core/http/auth-headers.ts
+function devPortalHeaders() {
+  if (!config?.devPortalId) {
+    return void 0;
+  }
+  return { "X-Dev-Portal-Id": config.devPortalId };
+}
+function mergeRequestOptions(token, extraHeaders) {
+  const bearerToken = token || getAccessToken();
+  const headers = { ...extraHeaders };
+  if (bearerToken) {
+    headers.Authorization = `Bearer ${bearerToken}`;
+  }
+  const devHeaders = devPortalHeaders();
+  if (devHeaders) {
+    Object.assign(headers, devHeaders);
+  }
+  return Object.keys(headers).length > 0 ? { headers } : void 0;
+}
+function hubIdQuery() {
+  return config.hubId ? { hubId: config.hubId } : null;
+}
+function portalIdQuery(portalId) {
+  const id = portalId ?? config.portalId ?? config.devPortalId;
+  if (id === null || id === void 0 || id === "") {
+    return void 0;
+  }
+  return { portalId: String(id) };
+}
+
+// src/main/features/auth/client/mfa-client.ts
+var mfaPortalQuery = (portalId) => portalIdQuery(portalId) ?? null;
+var mfaClient = {
+  verifyOtp: (data) => AuthHttpClient.post(generateApiUrl({ route: API_ENDPOINTS.VERIFY_OTP, queryParams: hubIdQuery() }), data, mergeRequestOptions(data.token)),
+  sendPendingOtp: (data) => AuthHttpClient.post(API_ENDPOINTS.MFA_PENDING_OTP_SEND, data, mergeRequestOptions(data.token)),
+  pendingPasskeyOptions: (data) => AuthHttpClient.post(API_ENDPOINTS.MFA_PENDING_PASSKEY_OPTIONS, data, mergeRequestOptions(data.token)),
+  pendingPasskeyVerify: (data) => AuthHttpClient.post(
+    generateApiUrl({ route: API_ENDPOINTS.MFA_PENDING_PASSKEY_VERIFY, queryParams: hubIdQuery() }),
+    data,
+    mergeRequestOptions(data.token)
+  ),
+  getStatus: (query) => HttpClient.get(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_STATUS,
+      queryParams: mfaPortalQuery(query?.portalId)
+    })
+  ),
+  setPreferences: (data, query) => HttpClient.put(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_PREFERENCES,
+      queryParams: mfaPortalQuery(query?.portalId)
+    }),
+    data
+  ),
+  startPhoneVerify: (data, query) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_PHONE_VERIFY_START,
+      queryParams: mfaPortalQuery(query?.portalId)
+    }),
+    data
+  ),
+  confirmPhoneVerify: (data, query) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_PHONE_VERIFY_CONFIRM,
+      queryParams: mfaPortalQuery(query?.portalId)
+    }),
+    data
+  ),
+  totpEnrollStart: (query) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_TOTP_ENROLL_START,
+      queryParams: mfaPortalQuery(query?.portalId)
+    }),
+    null
+  ),
+  totpEnrollVerify: (data) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_TOTP_ENROLL_VERIFY,
+      queryParams: mfaPortalQuery(data.portalId)
+    }),
+    data
+  ),
+  totpDisable: (data, query) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_TOTP_DISABLE,
+      queryParams: mfaPortalQuery(query?.portalId)
+    }),
+    data
+  ),
+  phoneUnverify: (data, query) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_PHONE_UNVERIFY,
+      queryParams: mfaPortalQuery(query?.portalId)
+    }),
+    data
+  ),
+  backupCodesRegenerate: (data, query) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_BACKUP_CODES_REGENERATE,
+      queryParams: mfaPortalQuery(query?.portalId)
+    }),
+    data
+  ),
+  optOut: (data, query) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_OPT_OUT,
+      queryParams: mfaPortalQuery(query?.portalId)
+    }),
+    data
+  ),
+  webauthnRegisterOptions: (query) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_WEBAUTHN_REGISTER_OPTIONS,
+      queryParams: mfaPortalQuery(query?.portalId)
+    }),
+    null,
+    mergeRequestOptions(void 0)
+  ),
+  webauthnRegisterVerify: (data) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_WEBAUTHN_REGISTER_VERIFY,
+      queryParams: mfaPortalQuery(data.portalId)
+    }),
+    data,
+    mergeRequestOptions(void 0)
+  ),
+  webauthnAuthOptions: (query) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_WEBAUTHN_AUTH_OPTIONS,
+      queryParams: mfaPortalQuery(query?.portalId)
+    }),
+    null,
+    mergeRequestOptions(void 0)
+  ),
+  webauthnAuthVerify: (data) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_WEBAUTHN_AUTH_VERIFY,
+      queryParams: mfaPortalQuery(data.portalId)
+    }),
+    data,
+    mergeRequestOptions(void 0)
+  ),
+  listWebauthnCredentials: (query) => HttpClient.get(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_WEBAUTHN_CREDENTIALS,
+      queryParams: mfaPortalQuery(query?.portalId)
+    }),
+    void 0,
+    mergeRequestOptions(void 0)
+  ),
+  deleteWebauthnCredential: (credentialRecordId, query) => HttpClient.delete(
+    generateApiUrl({
+      route: API_ENDPOINTS.MFA_WEBAUTHN_CREDENTIAL_DELETE,
+      params: { credentialRecordId: String(credentialRecordId) },
+      queryParams: mfaPortalQuery(query?.portalId)
+    })
+  ),
+  passkeyLoginOptions: (data) => AuthHttpClient.post(
+    generateApiUrl({ route: API_ENDPOINTS.PASSKEY_LOGIN_OPTIONS, queryParams: hubIdQuery() }),
+    data,
+    mergeRequestOptions(void 0)
+  ),
+  passkeyLoginVerify: (data) => AuthHttpClient.post(
+    generateApiUrl({ route: API_ENDPOINTS.PASSKEY_LOGIN_VERIFY, queryParams: hubIdQuery() }),
+    data,
+    mergeRequestOptions(void 0)
+  )
+};
+
+// src/main/features/crm/helpers/normalize-table-list-params.ts
+function resolveListTableParams(payload) {
+  const param = tableUiActions.getTableParam(payload?.companyAsMediator, payload?.currentPageOverride);
+  if (payload?.tableParams && typeof payload.tableParams === "object") {
+    return { ...param, ...payload.tableParams };
+  }
+  return { ...param };
+}
+function applyBoardPaginationToParams(param, tableParams) {
+  const stageId = tableParams.stageId;
+  const page = tableParams.page;
+  if (stageId !== void 0 && stageId !== null && stageId !== "") {
+    param.stageId = stageId;
+  }
+  if (param.view === "BOARD" && page !== void 0) {
+    param.page = page;
+  }
+  return param;
+}
+function finalizeBoardListQueryParams(param, _context) {
+  const { stageId, nextPage, view, selectedPipeline, selectedStage } = tableUiStore.getState();
+  if (view) {
+    param.view = view;
+  }
+  if (selectedPipeline !== void 0 && selectedPipeline !== null && String(selectedPipeline) !== "") {
+    param.filterValue = selectedPipeline;
+  }
+  const effectiveView = String(param.view ?? view ?? "");
+  const hadSelectedStageKey = Object.prototype.hasOwnProperty.call(param, "selectedStage");
+  const urlSelectedStage = param.selectedStage;
+  delete param.selectedStage;
+  if (effectiveView === "LIST") {
+    const pipelineValue = param.filterValue;
+    const hasPipeline = pipelineValue !== void 0 && pipelineValue !== null && String(pipelineValue) !== "";
+    const fromStore = selectedStage !== void 0 && selectedStage !== null && String(selectedStage) !== "" ? String(selectedStage) : "";
+    const fromUrl = urlSelectedStage !== void 0 && urlSelectedStage !== null && String(urlSelectedStage) !== "" ? String(urlSelectedStage) : "";
+    const listStage = hadSelectedStageKey ? fromUrl : fromStore;
+    if (listStage && hasPipeline) {
+      param.stageId = listStage;
+      if (!fromStore && fromUrl) {
+        tableUiStore.setState({ selectedStage: fromUrl });
+      }
+    } else {
+      delete param.stageId;
+    }
+    return param;
+  }
+  return applyBoardPaginationToParams(param, {
+    stageId,
+    page: stageId ? nextPage : 1
+  });
+}
+
+// src/main/core/utils/cache/resolveCrmListPurgeQuery.ts
+var LIST_QUERY_KEYS = [
+  "sort",
+  "search",
+  "filterPropertyName",
+  "filterOperator",
+  "filterValue",
+  "page",
+  "limit",
+  "view",
+  "mediatorObjectTypeId",
+  "mediatorObjectRecordId",
+  "parentObjectTypeId",
+  "parentObjectRecordId",
+  "stageId",
+  "after"
+];
+var PURGE_FILTER_KEYS = ["sort", "filterPropertyName", "filterOperator", "filterValue", "view", "page", "limit"];
+function hasPurgeFilterContext(raw) {
+  if (!raw || typeof raw !== "object") {
+    return false;
+  }
+  return PURGE_FILTER_KEYS.some((key) => {
+    const value = raw[key];
+    return value !== void 0 && value !== null && String(value).length > 0;
+  });
+}
+function mergeLiveTableUiState(raw) {
+  const state = tableUiStore.getState();
+  const merged = { ...raw ?? {} };
+  if (!merged.sort && state.sort) {
+    merged.sort = state.sort;
+  }
+  if (!merged.search && state.search) {
+    merged.search = state.search;
+  }
+  if (!merged.filterPropertyName && state.filterPropertyName) {
+    merged.filterPropertyName = state.filterPropertyName;
+  }
+  if (!merged.filterOperator && state.filterOperator) {
+    merged.filterOperator = state.filterOperator;
+  }
+  if (!merged.filterValue && state.selectedPipeline) {
+    merged.filterValue = state.selectedPipeline;
+  }
+  if (merged.limit === void 0 && state.limit) {
+    merged.limit = state.limit;
+  }
+  if (merged.page === void 0 && state.page !== void 0 && state.page !== "") {
+    merged.page = state.page;
+  }
+  if (!merged.view && state.view) {
+    merged.view = state.view;
+  }
+  if (merged.isPrimaryCompany === void 0 && state.isPrimaryCompany !== null) {
+    merged.isPrimaryCompany = state.isPrimaryCompany;
+  }
+  return applyBoardPaginationToParams(merged, {
+    stageId: state.stageId,
+    page: state.stageId ? state.nextPage : 1
+  });
+}
+function listQueryCacheKey(q) {
+  return JSON.stringify({
+    ...q,
+    stageId: q.stageId ?? ""
+  });
+}
+function toCachePurgeListQuery(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { page: 1, limit: 10, view: "LIST" };
+  }
+  const q = {};
+  for (const key of LIST_QUERY_KEYS) {
+    const value = raw[key];
+    if (value !== void 0 && value !== null && String(value).length > 0) {
+      q[key] = String(value);
+    }
+  }
+  if (raw.page !== void 0 && raw.page !== null) {
+    const page = Number(raw.page);
+    if (!Number.isNaN(page) && page > 0) {
+      q.page = page;
+    }
+  }
+  if (raw.limit !== void 0 && raw.limit !== null) {
+    const limit = Number(raw.limit);
+    if (!Number.isNaN(limit) && limit > 0) {
+      q.limit = limit;
+    }
+  }
+  const isPc = raw.isPrimaryCompany ?? raw.isPC;
+  if (isPc !== void 0 && isPc !== null) {
+    q.isPrimaryCompany = isPc === true || isPc === "true" || isPc === 1 || isPc === "1";
+  }
+  const view = raw.view;
+  if (typeof view === "string") {
+    q.view = view.toUpperCase() === "BOARD" ? "BOARD" : "LIST";
+  }
+  if (Object.keys(q).length === 0) {
+    return { page: 1, limit: 10, view: "LIST" };
+  }
+  if (q.page === void 0) {
+    q.page = 1;
+  }
+  if (q.limit === void 0) {
+    q.limit = 10;
+  }
+  if (q.view === void 0) {
+    q.view = "LIST";
+  }
+  return q;
+}
+function expandListPurgeQueriesForCrmWrite(base) {
+  const listQuery = { ...base, view: "LIST" };
+  delete listQuery.stageId;
+  const boardQuery = { ...base, view: "BOARD" };
+  const seen = /* @__PURE__ */ new Set();
+  const expanded = [];
+  for (const query of [listQuery, boardQuery]) {
+    const key = listQueryCacheKey(query);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    expanded.push(query);
+  }
+  return expanded;
+}
+function applyFilterValueFromPipelineState(query) {
+  if (query.filterValue) {
+    return query;
+  }
+  const { filterPropertyName, filterOperator } = query;
+  if (!filterPropertyName || !filterOperator) {
+    return query;
+  }
+  const selectedPipeline = tableUiStore.getState().selectedPipeline;
+  if (!selectedPipeline) {
+    return query;
+  }
+  return { ...query, filterValue: selectedPipeline };
+}
+function resolveCrmListPurgeQuery(options) {
+  let raw;
+  if (options.componentName === "sidebarTable" && options.hubspotObjectTypeId) {
+    raw = options.multiObjectsQueryParams?.[String(options.hubspotObjectTypeId)] ?? null;
+  } else {
+    raw = options.tableQueryParams ?? null;
+  }
+  if (!hasPurgeFilterContext(raw)) {
+    raw = mergeLiveTableUiState(raw);
+  }
+  let base = applyFilterValueFromPipelineState(toCachePurgeListQuery(raw ?? void 0));
+  if (!options.writeContext || Object.keys(options.writeContext).length === 0) {
+    return base;
+  }
+  base = {
+    ...base,
+    ...options.writeContext
+  };
+  return applyFilterValueFromPipelineState(base);
+}
+
+// src/main/core/utils/cache/crmCacheRefresh.ts
+function buildPostWriteListPurgeTargets(objectTypeId, listQuery, recordIds) {
+  const base = listQuery ?? { page: 1, limit: 10, view: "LIST" };
+  return expandListPurgeQueriesForCrmWrite(base).map((query) => buildCrmListPurgeTarget(objectTypeId, query, recordIds));
+}
+async function purgeCrmObjectDataCache(options) {
+  const result = await purgeCrmListCache(options);
+  return result.ok;
+}
+async function purgeCrmListCacheAfterCrmWrite(options) {
+  const objectTypeId = options.objectTypeId?.trim();
+  if (!objectTypeId) {
+    return { ok: false, errorCode: "VALIDATION", message: "objectTypeId is required" };
+  }
+  return purgeCrmCombined({
+    ...options,
+    postCrmWrite: true,
+    targets: buildPostWriteListPurgeTargets(objectTypeId, options.listQuery, options.recordIds)
+  });
+}
+async function purgeCrmDetailAndListAfterCrmWrite(options) {
+  const objectTypeId = options.objectTypeId?.trim();
+  if (!objectTypeId || !options.recordIds?.length) {
+    return {
+      ok: false,
+      errorCode: "VALIDATION",
+      message: "objectTypeId and recordIds are required"
+    };
+  }
+  return purgeCrmCombined({
+    ...options,
+    postCrmWrite: true,
+    targets: mergePurgeTargets(
+      ...buildPostWriteListPurgeTargets(objectTypeId, options.listQuery, options.recordIds),
+      buildCrmSinglePurgeTarget(objectTypeId, options.recordIds, options.listQuery)
+    )
+  });
+}
+async function purgeCrmListCache(options) {
+  const objectTypeId = options.objectTypeId?.trim();
+  if (!objectTypeId) {
+    return { ok: false, errorCode: "VALIDATION", message: "objectTypeId is required" };
+  }
+  const target = buildCrmListPurgeTarget(objectTypeId, options.listQuery, options.recordIds);
+  const request = buildCachePurgeRequest([target], {
+    mode: options.mode,
+    warm: options.warm,
+    postCrmWrite: options.postCrmWrite,
+    warmListDelayMs: options.warmListDelayMs
+  });
+  return createCachePurgeJob(request, {
+    idempotencyKey: options.idempotencyKey,
+    waitForWarm: options.waitForWarm,
+    pollTimeoutMs: options.pollTimeoutMs,
+    pollIntervalMs: options.pollIntervalMs
+  });
+}
+async function purgeCrmRecordCache(options) {
+  const objectTypeId = options.objectTypeId?.trim();
+  if (!objectTypeId || !options.recordIds?.length) {
+    return {
+      ok: false,
+      errorCode: "VALIDATION",
+      message: "objectTypeId and recordIds are required"
+    };
+  }
+  const target = buildCrmSinglePurgeTarget(objectTypeId, options.recordIds, options.listQuery);
+  const request = buildCachePurgeRequest([target], {
+    mode: options.mode,
+    warm: options.warm,
+    postCrmWrite: options.postCrmWrite,
+    warmListDelayMs: options.warmListDelayMs
+  });
+  return createCachePurgeJob(request, {
+    idempotencyKey: options.idempotencyKey,
+    waitForWarm: options.waitForWarm,
+    pollTimeoutMs: options.pollTimeoutMs,
+    pollIntervalMs: options.pollIntervalMs
+  });
+}
+async function purgeEngagementCaches(options) {
+  return purgeEngagementCachesInternal(options);
+}
+async function purgeEngagementCachesAfterCrmWrite(options) {
+  return purgeEngagementCachesInternal({
+    ...options,
+    postCrmWrite: true
+  });
+}
+async function purgeEngagementCachesInternal(options) {
+  const objectTypeId = options.objectTypeId?.trim();
+  if (!objectTypeId || !options.recordIds?.length || !options.views?.length) {
+    return {
+      ok: false,
+      errorCode: "VALIDATION",
+      message: "objectTypeId, recordIds, and views are required"
+    };
+  }
+  const target = buildEngagementPurgeTarget(objectTypeId, options.recordIds, options.views, {
+    fileIds: options.fileIds,
+    listQuery: options.listQuery,
+    engagementItemIds: options.engagementItemIds
+  });
+  const request = buildCachePurgeRequest([target], {
+    mode: options.mode,
+    warm: options.warm,
+    postCrmWrite: options.postCrmWrite,
+    warmListDelayMs: options.warmListDelayMs
+  });
+  return createCachePurgeJob(request, {
+    idempotencyKey: options.idempotencyKey,
+    waitForWarm: options.waitForWarm,
+    pollTimeoutMs: options.pollTimeoutMs,
+    pollIntervalMs: options.pollIntervalMs
+  });
+}
+async function purgeCrmAssociationCaches(options) {
+  const parentObjectTypeId = options.parentObjectTypeId?.trim();
+  const parentRecordId = options.parentRecordId?.trim();
+  if (!parentObjectTypeId || !parentRecordId) {
+    return {
+      ok: false,
+      errorCode: "VALIDATION",
+      message: "parentObjectTypeId and parentRecordId are required"
+    };
+  }
+  const childIds = [
+    ...options.childObjectTypeIds ?? [],
+    ...options.objectTypeId ? [options.objectTypeId] : []
+  ].map((id) => String(id).trim()).filter((id, index, all) => id.length > 0 && all.indexOf(id) === index);
+  const parentListQuery = {
+    ...options.listQuery ?? { page: 1, limit: 10, view: "LIST" },
+    parentObjectTypeId,
+    parentObjectRecordId: parentRecordId
+  };
+  const listTargets = childIds.flatMap(
+    (childId) => options.postCrmWrite ? buildPostWriteListPurgeTargets(childId, parentListQuery, options.recordIds) : [buildCrmListPurgeTarget(childId, parentListQuery, options.recordIds)]
+  );
+  const singleTarget = buildCrmSinglePurgeTarget(parentObjectTypeId, [parentRecordId], parentListQuery);
+  const engagementViews = options.engagementViews?.filter(Boolean) ?? [];
+  const engagementTargets = engagementViews.length > 0 ? [
+    buildEngagementPurgeTarget(parentObjectTypeId, [parentRecordId], engagementViews, {
+      listQuery: parentListQuery,
+      fileIds: options.fileIds,
+      engagementItemIds: options.engagementItemIds
+    })
+  ] : [];
+  if (listTargets.length === 0 && engagementTargets.length === 0) {
+    return purgeCrmCombined({
+      ...options,
+      targets: [singleTarget]
+    });
+  }
+  return purgeCrmCombined({
+    ...options,
+    objectTypeId: childIds[0] ?? parentObjectTypeId,
+    targets: mergePurgeTargets(...listTargets, singleTarget, ...engagementTargets)
+  });
+}
+async function purgeCrmCombined(options) {
+  const request = buildCachePurgeRequest(options.targets, {
+    mode: options.mode,
+    warm: options.warm,
+    postCrmWrite: options.postCrmWrite,
+    warmListDelayMs: options.warmListDelayMs
+  });
+  return createCachePurgeJob(request, {
+    idempotencyKey: options.idempotencyKey,
+    waitForWarm: options.waitForWarm,
+    pollTimeoutMs: options.pollTimeoutMs,
+    pollIntervalMs: options.pollIntervalMs
+  });
+}
+
+// src/main/core/utils/cache/extractHubspotRecordIdFromWriteResponse.ts
+function extractHubspotRecordIdFromWriteResponse(response) {
+  if (response == null || typeof response !== "object") {
+    return void 0;
+  }
+  const root = response;
+  const data = root.data;
+  if (data != null && typeof data === "object") {
+    const fromData = idFromRecordPayload(data);
+    if (fromData) {
+      return fromData;
+    }
+  }
+  return idFromRecordPayload(root);
+}
+function idFromRecordPayload(payload) {
+  const id = payload.id;
+  if (id !== void 0 && id !== null && String(id).length > 0) {
+    return String(id);
+  }
+  const hsObjectId = payload.hs_object_id;
+  if (hsObjectId !== void 0 && hsObjectId !== null && String(hsObjectId).length > 0) {
+    return String(hsObjectId);
+  }
+  return void 0;
+}
+
+// src/main/core/utils/cache/extractEngagementItemIdFromWriteResponse.ts
+function extractEngagementItemIdFromWriteResponse(response) {
+  if (response == null || typeof response !== "object") {
+    return void 0;
+  }
+  const root = response;
+  const candidates = [];
+  const data = root.data;
+  if (data != null && typeof data === "object") {
+    const dataObj = data;
+    candidates.push(dataObj);
+    const nested = dataObj.response;
+    if (nested != null && typeof nested === "object") {
+      candidates.push(nested);
+    }
+  }
+  const topResponse = root.response;
+  if (topResponse != null && typeof topResponse === "object") {
+    candidates.push(topResponse);
+  }
+  candidates.push(root);
+  for (const payload of candidates) {
+    const id = engagementIdFromPayload(payload);
+    if (id) {
+      return id;
+    }
+  }
+  return void 0;
+}
+function engagementIdFromPayload(payload) {
+  const fromHs = fieldValue(payload.hs_object_id);
+  if (fromHs) {
+    return fromHs;
+  }
+  const fromId = fieldValue(payload.id);
+  if (fromId) {
+    return fromId;
+  }
+  return void 0;
+}
+function fieldValue(raw) {
+  if (raw == null) {
+    return void 0;
+  }
+  if (typeof raw === "object") {
+    const value = raw.value;
+    if (value !== void 0 && value !== null && String(value).length > 0) {
+      return String(value);
+    }
+    return void 0;
+  }
+  const s = String(raw);
+  return s.length > 0 ? s : void 0;
+}
+
+// src/main/core/http/client-context.ts
+function getParamDetails2(...args) {
+  return navigationApi.route.getParamDetails(...args);
+}
+var recordWriteContext = (paramsObject) => {
+  if (!paramsObject) {
+    return void 0;
+  }
+  const context = {};
+  const keys = ["parentObjectTypeId", "parentObjectRecordId", "mediatorObjectTypeId", "mediatorObjectRecordId"];
+  keys.forEach((key) => {
+    const value = paramsObject[key];
+    if (value !== void 0 && value !== null && String(value).length > 0) {
+      context[key] = String(value);
+    }
+  });
+  return Object.keys(context).length > 0 ? context : void 0;
+};
+var triggerPostWriteListPurge = async (props) => {
+  const objectTypeId = props.hubspotObjectTypeId;
+  if (!objectTypeId) {
+    return;
+  }
+  if (getClientType() === "mobile") {
+    return;
+  }
+  const { queryParams, multiObjectsQueryParams } = tableStore.getState();
+  const writeContext = recordWriteContext(props.paramsObject);
+  const listQuery = resolveCrmListPurgeQuery({
+    componentName: props.componentName,
+    hubspotObjectTypeId: objectTypeId,
+    tableQueryParams: queryParams,
+    multiObjectsQueryParams,
+    writeContext
+  });
+  const recordIds = props.recordId ? [String(props.recordId)] : void 0;
+  const parentObjectTypeId = writeContext?.parentObjectTypeId;
+  const parentRecordId = writeContext?.parentObjectRecordId;
+  try {
+    if (parentObjectTypeId && parentRecordId) {
+      await purgeCrmAssociationCaches({
+        objectTypeId: String(objectTypeId),
+        parentObjectTypeId,
+        parentRecordId,
+        listQuery,
+        recordIds,
+        postCrmWrite: true,
+        waitForWarm: true,
+        pollTimeoutMs: 45e3
+      });
+      return;
+    }
+    await purgeCrmListCacheAfterCrmWrite({
+      objectTypeId: String(objectTypeId),
+      listQuery,
+      recordIds,
+      waitForWarm: true,
+      pollTimeoutMs: 45e3
+    });
+  } catch {
+  }
+};
+var mergeRecordWriteBody = (payload, paramsObject, options) => {
+  const base = { ...payload || {} };
+  const context = recordWriteContext(paramsObject);
+  if (context) {
+    base.context = context;
+  }
+  if (options && Object.keys(options).length > 0) {
+    base.options = options;
+  }
+  return base;
+};
+
+// src/main/features/auth/client/authentication-client.ts
+function hubPortalQuery(hubId, portalId) {
+  const queryParams = {};
+  if (hubId != null) {
+    queryParams.hubId = hubId;
+  }
+  const resolvedPortalId = portalId ?? (config?.devPortalId != null && String(config.devPortalId).trim() !== "" ? Number(config.devPortalId) : void 0);
+  if (resolvedPortalId != null && !Number.isNaN(resolvedPortalId)) {
+    queryParams.portalId = resolvedPortalId;
+  }
+  return Object.keys(queryParams).length > 0 ? queryParams : void 0;
+}
+var authenticationClient = {
+  authentication: {
+    preLogin: (data) => {
+      const email = data.email ?? data.username;
+      return AuthHttpClient.post(
+        generateApiUrl({ route: API_ENDPOINTS.PRE_LOGIN, queryParams: hubPortalQuery(data.hubId, data.portalId) }),
+        { email }
+      );
+    },
+    login: (data) => {
+      const queryParams = config.hubId ? { hubId: config.hubId } : null;
+      const username = (data.username ?? data.email)?.trim();
+      const body = {
+        username,
+        password: typeof data.password === "string" ? data.password.trim() : data.password,
+        ...data.rememberMe != null ? { rememberMe: data.rememberMe } : {}
+      };
+      return AuthHttpClient.post(
+        generateApiUrl({ route: API_ENDPOINTS.LOGIN, queryParams }),
+        body,
+        config?.devPortalId && {
+          headers: {
+            "X-Dev-Portal-Id": config.devPortalId
+          }
+        }
+      );
+    },
+    verifyOtp: (data) => mfaClient.verifyOtp(data),
+    verifyEmail: (data) => AuthHttpClient.post(API_ENDPOINTS.VERIFY_EMAIL, data),
+    register: (data) => AuthHttpClient.post("/register", data),
+    resetPasswordVerifyToken: (data) => AuthHttpClient.post(API_ENDPOINTS.RESET_PASSWORD_VERIFY_TOKEN, data),
+    resetPassword: (data) => AuthHttpClient.post(API_ENDPOINTS.RESET_PASSWORD, {
+      ...data,
+      token: typeof data.token === "string" ? data.token.trim() : data.token,
+      newPassword: typeof data.newPassword === "string" ? data.newPassword.trim() : data.newPassword,
+      confirmPassword: typeof data.confirmPassword === "string" ? data.confirmPassword.trim() : data.confirmPassword
+    }),
+    forgetPassword: (data) => AuthHttpClient.post(API_ENDPOINTS.FORGET_PASSWORD, {
+      ...data,
+      email: typeof data.email === "string" ? data.email.trim().toLowerCase() : data.email
+    }),
+    verifyForgotPasswordOtp: (data) => AuthHttpClient.post(API_ENDPOINTS.FORGET_PASSWORD_OTP_VERIFY, data),
+    registerExistingUser: (data) => AuthHttpClient.post(API_ENDPOINTS.REGISTER_EXISTING_USER, data?.payload),
+    verifyEmailResend: (data) => AuthHttpClient.post(API_ENDPOINTS.VERIFY_EMAIL_RESEND, data),
+    resendEmail: (data) => AuthHttpClient.post(API_ENDPOINTS.RESEND_EMAIL, data),
+    logout: () => HttpClient.post(API_ENDPOINTS.LOGOUT, null, {
+      skipGlobalAuthRedirect: true
+    }),
+    clientSession: (payload) => AuthHttpClient.post(
+      API_ENDPOINTS.CLIENT_SESSION,
+      { refreshToken: payload.refreshToken ?? payload.accessToken },
+      {
+        headers: {
+          Authorization: `Bearer ${payload.accessToken}`
+        }
+      }
+    ),
+    handoff: (payload) => AuthHttpClient.post(
+      generateApiUrl({
+        route: API_ENDPOINTS.AUTH_HANDOFF,
+        queryParams: { hubId: payload.hubId }
+      }),
+      { code: payload.code }
+    ),
+    getLoginBootstrap: (payload) => AuthHttpClient.get(
+      generateApiUrl({
+        route: API_ENDPOINTS.LOGIN_BOOTSTRAP,
+        queryParams: hubPortalQuery(payload?.hubId, payload?.portalId)
+      })
+    ),
+    signInLink: {
+      send: (data) => AuthHttpClient.post(
+        generateApiUrl({
+          route: API_ENDPOINTS.SIGN_IN_LINK_SEND,
+          queryParams: hubPortalQuery(data.hubId, data.portalId)
+        }),
+        { email: data.email }
+      ),
+      verify: (data) => AuthHttpClient.post(API_ENDPOINTS.SIGN_IN_LINK_VERIFY, data),
+      validateToken: (token) => AuthHttpClient.get(
+        generateApiUrl({
+          route: API_ENDPOINTS.SIGN_IN_LINK_VALIDATE,
+          queryParams: { token }
+        })
+      )
+    }
+  },
+  sso: {
+    getSsoDetails: () => AuthHttpClient.get(API_ENDPOINTS.SSO_DETAILS),
+    generateSsoUrl: (payload) => AuthHttpClient.get(generateApiUrl({ route: API_ENDPOINTS.SSO_URL, queryParams: payload?.queryParams })),
+    ssoCallback: (payload) => AuthHttpClient.get(generateApiUrl({ route: API_ENDPOINTS.SSO_CALLBACK, queryParams: payload?.queryParams }))
+  },
+  user: {
+    me: () => HttpClient.get(generateApiUrl({ route: API_ENDPOINTS.ME })),
+    profile: (payload) => HttpClient.get(generateApiUrl({ route: API_ENDPOINTS.PROFILE, queryParams: payload })),
+    profileUpdate: (props) => {
+      const properties = props?.properties ?? props?.payload ?? {};
+      return HttpClient.put(generateApiUrl({ route: API_ENDPOINTS.PROFILE_UPDATE, queryParams: props?.queryParams || {} }), { properties });
+    },
+    changePassword: (data) => HttpClient.post(API_ENDPOINTS.CHANGE_PASSWORD, data)
+  }
+};
+
+// src/main/features/crm/client/crm-client.ts
+function resolveCrmObjectRouteParams(payload) {
+  const hubspotObjectTypeId = payload?.hubspotObjectTypeId ?? payload?.params?.hubspotObjectTypeId;
+  return {
+    ...payload?.params || {},
+    ...hubspotObjectTypeId ? { hubspotObjectTypeId } : {}
+  };
+}
+var crmClient = {
+  pipeline: {
+    list: (payload = null, listTableParams = null) => {
+      const params = resolveCrmObjectRouteParams(payload);
+      const queryParams = payload?.queryParams;
+      const { paramsObject } = getParamDetails2({ type: payload?.componentName });
+      const userData = userStore.getState().profile;
+      const apiParams = {};
+      const tableParams = payload?.tableParams && typeof payload.tableParams === "object" ? payload.tableParams : {};
+      const parentObjectTypeId = paramsObject?.parentObjectTypeId ?? listTableParams?.parentObjectTypeId ?? tableParams.parentObjectTypeId;
+      if (parentObjectTypeId) {
+        apiParams.parentObjectTypeId = parentObjectTypeId;
+      } else if (payload?.isHome && userData?.crmProfile?.info?.objectTypeId && !listTableParams?.isPrimaryCompany) {
+        apiParams.parentObjectTypeId = userData?.crmProfile?.info?.objectTypeId;
+      } else if (payload?.isHome && userData?.crmProfile?.info?.objectTypeId && listTableParams?.isPrimaryCompany) {
+        apiParams.parentObjectTypeId = "0-2";
+      }
+      const isPrimaryCompany = listTableParams?.isPrimaryCompany ?? tableParams.isPrimaryCompany ?? paramsObject?.isPrimaryCompany;
+      if (isPrimaryCompany !== void 0 && isPrimaryCompany !== null && isPrimaryCompany !== "") {
+        apiParams.isPrimaryCompany = isPrimaryCompany;
+      }
+      const apiUrl = generateApiUrl({
+        route: API_ENDPOINTS.PIPELINES,
+        params,
+        queryParams: { ...apiParams, ...queryParams }
+      });
+      return HttpClient.get(apiUrl);
+    }
+  },
+  stage: {
+    list: (payload = null) => {
+      const params = resolveCrmObjectRouteParams(payload);
+      const queryParams = payload?.queryParams;
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.STAGES, params, queryParams });
+      return HttpClient.get(apiUrl);
+    }
+  },
+  object: {
+    list: async (payload = null, listTableParams = null) => {
+      const { setObjectsQueryParams } = actions2;
+      const params = resolveCrmObjectRouteParams(payload);
+      const queryParams = payload?.queryParams;
+      const { updateLink: updateLink2, getLinkParams } = updateLink();
+      const tabHubspotObjectTypeId = payload?.hubspotObjectTypeId ?? payload?.params?.hubspotObjectTypeId;
+      const linkParamDisplayName = payload?.viewName === "tabs" && tabHubspotObjectTypeId ? `tabs.${tabHubspotObjectTypeId}.prm` : "prm";
+      const { paramsObject, parentAccessLabel } = getParamDetails2({ type: payload?.componentName, viewName: payload?.viewName });
+      const userData = userStore.getState().profile;
+      const pipeline = payload?.variables?.pipeline;
+      const mPipelines = payload?.variables?.mPipelines;
+      const mSelectedPipeline = pipeline !== void 0 ? pipeline : payload?.selectedPipeline;
+      if (mSelectedPipeline !== void 0 && mSelectedPipeline !== null && String(mSelectedPipeline) !== "") {
+        listTableParams.filterValue = mSelectedPipeline;
+      } else if (payload?.specPipeLine && payload?.pipeLineId != null && String(payload.pipeLineId) !== "") {
+        listTableParams.filterValue = payload?.pipeLineId;
+      } else if (payload?.lockedPipelineId != null && String(payload.lockedPipelineId) !== "") {
+        listTableParams.filterValue = payload.lockedPipelineId;
+      } else if (!isPipelineBoardObjectTypeId(payload?.hubspotObjectTypeId)) {
+        listTableParams.filterValue = "";
+      }
+      const fParams = getLinkParams(linkParamDisplayName);
+      listTableParams = { ...payload?.isFristTimeLoadData && fParams && !payload?.isHome ? fParams : listTableParams, ...paramsObject };
+      if (payload?.isHome) {
+        listTableParams.isPrimaryCompany = payload.companyAsMediator === true;
+      }
+      if (!payload?.isFristTimeLoadData || !fParams) {
+        const selectedStage = tableUiStore.getState().selectedStage;
+        await updateLink2(
+          {
+            sort: listTableParams?.sort,
+            s: listTableParams?.search,
+            fPn: listTableParams?.filterPropertyName,
+            fO: listTableParams?.filterOperator,
+            fV: listTableParams?.filterValue,
+            // "c": listTableParams?.cache,
+            isPC: listTableParams?.isPrimaryCompany,
+            v: listTableParams?.view,
+            l: listTableParams?.limit,
+            p: listTableParams?.page,
+            a: listTableParams?.after,
+            stg: listTableParams?.view === "LIST" ? selectedStage || "" : void 0
+          },
+          linkParamDisplayName
+        );
+      }
+      if (mPipelines != void 0 && mPipelines?.length === 0 && !payload?.specPipeLine) {
+        listTableParams.filterValue = "";
+        await updateLink2(
+          {
+            fV: listTableParams?.filterValue
+          },
+          linkParamDisplayName
+        );
+      }
+      if (mPipelines != void 0 && mPipelines?.length === 1 && !payload?.specPipeLine && mSelectedPipeline != null) {
+        listTableParams.filterValue = mPipelines[0].pipelineId;
+        await updateLink2(
+          {
+            fV: listTableParams?.filterValue
+          },
+          linkParamDisplayName
+        );
+      }
+      if (payload?.isHome || payload?.hubspotObjectTypeId === "0-5" && payload?.componentName === "object") {
+        let parentObjectTypeId = "";
+        if (userData?.crmProfile?.info?.objectTypeId && !listTableParams?.isPrimaryCompany) {
+          parentObjectTypeId = userData?.crmProfile?.info?.objectTypeId;
+        } else if (userData?.crmProfile?.info?.objectTypeId && listTableParams?.isPrimaryCompany) {
+          parentObjectTypeId = "0-2";
+        }
+        listTableParams.parentObjectTypeId = parentObjectTypeId;
+      }
+      listTableParams.parentAccessLabel = parentAccessLabel;
+      finalizeBoardListQueryParams(listTableParams);
+      setObjectsQueryParams(listTableParams);
+      listTableParams = { ...listTableParams, ...queryParams };
+      const route = payload?.public ? API_ENDPOINTS.OBJECTS_PUBLIC : API_ENDPOINTS.OBJECTS;
+      const apiUrl = generateApiUrl({ route, params, queryParams: listTableParams });
+      return HttpClient.get(apiUrl);
+    },
+    existingList: async (payload = null) => {
+      const hubspotObjectTypeId = payload?.hubspotObjectTypeId;
+      const params = { ...{ hubspotObjectTypeId }, ...payload?.params };
+      const { paramsObject } = getParamDetails2({ type: payload?.componentName });
+      const queryParams = { ...{ parentObjectTypeId: paramsObject?.parentObjectTypeId }, ...payload?.queryParams };
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.RECORDS_EXISTING, params, queryParams });
+      return HttpClient.get(apiUrl);
+    },
+    addExistingList: async (payload = null) => {
+      const hubspotObjectTypeId = payload?.hubspotObjectTypeId;
+      const { paramsObject } = getParamDetails2({ type: payload?.componentName });
+      const params = { ...{ hubspotObjectTypeId, parentObjectTypeId: paramsObject?.parentObjectTypeId, recordId: paramsObject?.parentObjectRecordId }, ...payload?.params };
+      const queryParams = payload?.queryParams;
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.RECORDS_ADD_EXISTING, params, queryParams });
+      return HttpClient.post(apiUrl, payload?.payload);
+    },
+    sideBarList: async (payload = null) => {
+      const { setMultiObjectsQueryParams } = actions2;
+      const hubspotObjectTypeId = payload?.hubspotObjectTypeId;
+      const params = payload?.params;
+      const queryParams = payload?.queryParams;
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.OBJECTS, params, queryParams });
+      setMultiObjectsQueryParams(hubspotObjectTypeId, queryParams ?? {});
+      return HttpClient.get(apiUrl);
+    },
+    form: (payload = null) => {
+      const params = { hubspotObjectTypeId: payload?.hubspotObjectTypeId };
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.OBJECTS_FORM, params, queryParams: payload?.params });
+      return HttpClient.get(apiUrl);
+    },
+    objectFormOptions: (payload = null) => {
+      const params = payload?.params;
+      const queryParams = payload?.queryParams;
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.OBJECTS_FORM_OPTIONS, params, queryParams });
+      return HttpClient.get(apiUrl);
+    },
+    create: async (props = null) => {
+      const params = props?.params;
+      const queryParams = props?.queryParams;
+      const { paramsObject } = getParamDetails2({ type: props?.componentName });
+      const cardParentMerge = props?.componentName === "association" || props?.componentName === "sidebarAssociation" ? true : false;
+      const body = mergeRecordWriteBody(props?.payload, paramsObject, {
+        cardParentMerge,
+        addAnother: props?.params?.addAnother
+      });
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.RECORDS_CREATE, params, queryParams });
+      const response = await HttpClient.post(apiUrl, body);
+      const writeParams = {
+        ...paramsObject,
+        ...props?.queryParams && typeof props.queryParams === "object" ? props.queryParams : {},
+        ...props?.params && typeof props.params === "object" ? props.params : {}
+      };
+      const purgeArgs = {
+        hubspotObjectTypeId: props?.params?.hubspotObjectTypeId,
+        componentName: props?.componentName,
+        paramsObject: writeParams,
+        recordId: extractHubspotRecordIdFromWriteResponse(response)
+      };
+      if (props?.componentName === "sidebarAssociation") {
+        await triggerPostWriteListPurge(purgeArgs);
+      } else {
+        void triggerPostWriteListPurge(purgeArgs);
+      }
+      return response;
+    },
+    createExisting: async (props = null) => {
+      const { paramsObject } = getParamDetails2({ type: props?.componentName });
+      const { getLinkParams } = updateLink();
+      const fParams = getLinkParams();
+      const queryParams = { ...fParams, ...props?.params };
+      const params = {
+        fromObjectTypeId: props?.fromObjectTypeId ?? props?.hubspotObjectTypeId,
+        fromRecordId: props?.fromRecordId,
+        toObjectTypeId: props?.toObjectTypeId
+      };
+      const payload = props.payload;
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.RECORDS_ASSOCIATE, params, queryParams });
+      const response = await HttpClient.post(apiUrl, payload);
+      const objectTypeId = props?.toObjectTypeId ?? props?.hubspotObjectTypeId;
+      const recordId = extractHubspotRecordIdFromWriteResponse(response) ?? (props?.fromRecordId != null ? String(props.fromRecordId) : void 0);
+      triggerPostWriteListPurge({
+        hubspotObjectTypeId: objectTypeId,
+        componentName: props?.componentName,
+        paramsObject,
+        recordId
+      });
+      return response;
+    },
+    removeExisting: async (props = null) => {
+      const { paramsObject } = getParamDetails2({ type: props?.componentName });
+      const body = mergeRecordWriteBody(props?.payload, paramsObject, void 0);
+      const params = {
+        fromObjectTypeId: props?.fromObjectTypeId ?? props?.hubspotObjectTypeId,
+        fromRecordId: props?.fromRecordId,
+        toObjectTypeId: props?.toObjectTypeId
+      };
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.RECORDS_DISASSOCIATE, params });
+      const response = await HttpClient.delete(apiUrl, { data: body });
+      const objectTypeId = props?.toObjectTypeId ?? props?.hubspotObjectTypeId;
+      if (objectTypeId) {
+        const { queryParams, multiObjectsQueryParams } = tableStore.getState();
+        const listQuery = resolveCrmListPurgeQuery({
+          componentName: props?.componentName,
+          hubspotObjectTypeId: objectTypeId,
+          tableQueryParams: queryParams,
+          multiObjectsQueryParams,
+          writeContext: recordWriteContext(paramsObject)
+        });
+        purgeCrmListCache({
+          objectTypeId: String(objectTypeId),
+          listQuery
+        });
+      }
+      return response;
+    },
+    details: (props = null) => {
+      const isDdetails = props?.queryParams?.preview ? false : true;
+      const { paramsObject: urlParam, parentAccessLabel } = getParamDetails2("", isDdetails);
+      const hubspotObjectTypeId = ticketHubspotObjectTypeId();
+      const previewParams = makePreviewParams(props);
+      let objectId = null;
+      if (props?.queryParams?.preview) {
+        objectId = previewParams?.params?.objectId;
+      } else {
+        objectId = props?.params?.objectId;
+      }
+      const params = {
+        objectId,
+        id: props?.params?.id
+      };
+      let queryParams = {
+        parentAccessLabel,
+        ...props?.queryParams,
+        ...urlParam
+      };
+      if (props?.queryParams?.preview) {
+        queryParams = {
+          parentAccessLabel,
+          ...props?.queryParams,
+          ...previewParams?.queryParams
+        };
+      } else {
+        queryParams = {
+          parentAccessLabel,
+          ...props?.queryParams,
+          ...urlParam
+        };
+      }
+      if (hubspotObjectTypeId) queryParams.parentObjectTypeId = hubspotObjectTypeId;
+      const route = props?.public ? API_ENDPOINTS.OBJECTS_DETAILS_PUBLIC : API_ENDPOINTS.OBJECTS_DETAILS;
+      const apiUrl = generateApiUrl({ route, params, queryParams });
+      return HttpClient.get(apiUrl);
+    },
+    update: async (props = null) => {
+      const hubspotObjectTypeId = ticketHubspotObjectTypeId();
+      const params = props?.params;
+      const queryParams = props?.queryParams ?? {};
+      const { paramsObject } = getParamDetails2({ type: props?.componentName });
+      const cardParentMerge = props?.componentName === "association" ? true : false;
+      const rawPayload = props?.payload || {};
+      const properties = rawPayload.properties ?? rawPayload.propertyPayload ?? rawPayload;
+      const body = mergeRecordWriteBody({ properties }, paramsObject, { cardParentMerge });
+      if (hubspotObjectTypeId) queryParams.parentObjectTypeId = hubspotObjectTypeId;
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.RECORDS_UPDATE, params, queryParams });
+      if (props?.view === "board") {
+        body.options.view = "board";
+      }
+      const response = await HttpClient.put(apiUrl, body);
+      return response;
+    }
+  }
+};
+
+// src/main/features/crm/client/engagement-client.ts
+var engagementClient = {
+  note: {
+    list: (props = null) => {
+      const { setListQueryParams } = actions4;
+      setListQueryParams(props?.queryParams ?? {});
+      const params = {
+        // hubId: config.hubId,
+        // portalId: portalId,
+        objectId: props?.params?.objectId,
+        id: props?.params?.id
+      };
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.NOTES, params, queryParams: props?.queryParams });
+      return HttpClient.get(apiUrl);
+    },
+    create: async (props = null) => {
+      const params = { hubspotObjectTypeId: props?.hubspotObjectTypeId, ...props.params };
+      const queryParams = props.queryParams;
+      const payload = props.payload;
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.NOTES_CREATE, params, queryParams });
+      const listQuery = toCachePurgeListQuery(noteStore.getState().queryParams ?? {});
+      const response = await HttpClient.post(apiUrl, payload);
+      const recordId = props?.params?.id;
+      const objectTypeId = props?.params?.objectId;
+      if (recordId && objectTypeId) {
+        const engagementItemId = extractEngagementItemIdFromWriteResponse(response);
+        purgeEngagementCachesAfterCrmWrite({
+          objectTypeId,
+          recordIds: [String(recordId)],
+          views: ["notes"],
+          listQuery,
+          engagementItemIds: engagementItemId ? [engagementItemId] : void 0
+        });
+      }
+      return response;
+    },
+    update: async (props = null) => {
+      const params = {
+        // hubId: config.hubId,
+        // portalId: portalId,
+        objectId: props?.params?.objectId,
+        id: props?.params?.id,
+        note_id: props?.params?.note_id
+      };
+      const { paramsObject: queryParams } = getParamDetails2();
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.NOTES_DETAILS_UPDATE, params, queryParams });
+      const listQuery = toCachePurgeListQuery(noteStore.getState().queryParams ?? {});
+      const response = await HttpClient.put(apiUrl, props.payload);
+      const recordId = props?.params?.id;
+      const objectTypeId = props?.params?.objectId;
+      const noteId = props?.params?.note_id;
+      if (recordId && objectTypeId) {
+        const engagementItemId = extractEngagementItemIdFromWriteResponse(response) ?? (noteId != null && String(noteId).length > 0 ? String(noteId) : void 0);
+        purgeEngagementCachesAfterCrmWrite({
+          objectTypeId,
+          recordIds: [String(recordId)],
+          views: ["notes"],
+          listQuery,
+          engagementItemIds: engagementItemId ? [engagementItemId] : void 0
+        });
+      }
+      return response;
+    },
+    image: (props = null) => {
+      const params = { hubspotObjectTypeId: props?.hubspotObjectTypeId, ...props.params };
+      const queryParams = props.queryParams;
+      const payload = props.payload;
+      const axiosConfig = props.config || {};
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.NOTES_IMAGE_UPLOAD, params, queryParams });
+      return HttpClient.post(apiUrl, payload, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        },
+        ...axiosConfig
+      });
+    },
+    attachment: (props = null) => {
+      const params = { hubspotObjectTypeId: props?.hubspotObjectTypeId, ...props.params };
+      const queryParams = props.queryParams;
+      const payload = props.payload;
+      const axiosConfig = props.config || {};
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.NOTES_ATTACHMENT_UPLOAD, params, queryParams });
+      return HttpClient.post(apiUrl, payload, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        },
+        ...axiosConfig
+      });
+    }
+  },
+  email: {
+    list: (props = null) => {
+      const { setListQueryParams } = actions5;
+      setListQueryParams(props?.queryParams ?? {});
+      const params = {
+        // hubId: config.hubId,
+        // portalId: portalId,
+        objectId: props?.params?.objectId,
+        id: props?.params?.id
+      };
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.EMAILS, params, queryParams: props?.queryParams });
+      return HttpClient.get(apiUrl);
+    },
+    create: async (props = null) => {
+      const params = { hubspotObjectTypeId: props?.hubspotObjectTypeId, ...props.params };
+      const queryParams = props.queryParams;
+      const payload = props.payload;
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.EMAILS_CREATE, params, queryParams });
+      const listQuery = toCachePurgeListQuery(emailStore.getState().queryParams ?? {});
+      const response = await HttpClient.post(apiUrl, payload);
+      const recordId = props?.params?.id;
+      const objectTypeId = props?.params?.objectId;
+      if (recordId && objectTypeId) {
+        const engagementItemId = extractEngagementItemIdFromWriteResponse(response);
+        purgeEngagementCachesAfterCrmWrite({
+          objectTypeId,
+          recordIds: [String(recordId)],
+          views: ["emails"],
+          listQuery,
+          engagementItemIds: engagementItemId ? [engagementItemId] : void 0
+        });
+      }
+      return response;
+    },
+    update: async (props = null) => {
+      const params = {
+        // hubId: config.hubId,
+        // portalId: portalId,
+        objectId: props?.params?.objectId,
+        id: props?.params?.id,
+        email_id: props?.params?.email_id ?? props?.params?.note_id
+      };
+      const { paramsObject: queryParams } = getParamDetails2();
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.EMAILS_DETAILS_UPDATE, params, queryParams });
+      const listQuery = toCachePurgeListQuery(emailStore.getState().queryParams ?? {});
+      const response = await HttpClient.put(apiUrl, props.payload);
+      const recordId = props?.params?.id;
+      const objectTypeId = props?.params?.objectId;
+      const emailId = props?.params?.email_id ?? props?.params?.note_id;
+      if (recordId && objectTypeId) {
+        const engagementItemId = extractEngagementItemIdFromWriteResponse(response) ?? (emailId != null && String(emailId).length > 0 ? String(emailId) : void 0);
+        purgeEngagementCachesAfterCrmWrite({
+          objectTypeId,
+          recordIds: [String(recordId)],
+          views: ["emails"],
+          listQuery,
+          engagementItemIds: engagementItemId ? [engagementItemId] : void 0
+        });
+      }
+      return response;
+    },
+    image: (props = null) => {
+      const params = { hubspotObjectTypeId: props?.hubspotObjectTypeId, ...props.params };
+      const queryParams = props.queryParams;
+      const payload = props.payload;
+      const axiosConfig = props.config || {};
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.EMAILS_IMAGE_UPLOAD, params, queryParams });
+      return HttpClient.post(apiUrl, payload, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        },
+        ...axiosConfig
+      });
+    },
+    attachment: (props = null) => {
+      const params = { hubspotObjectTypeId: props?.hubspotObjectTypeId, ...props.params };
+      const queryParams = props.queryParams;
+      const payload = props.payload;
+      const axiosConfig = props.config || {};
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.EMAILS_ATTACHMENT_UPLOAD, params, queryParams });
+      return HttpClient.post(apiUrl, payload, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        },
+        ...axiosConfig
+      });
+    }
+  },
+  file: {
+    list: (props = null) => {
+      const { setListQueryParams } = actions7;
+      setListQueryParams(props?.queryParams ?? {});
+      const params = {
+        // hubId: config.hubId,
+        // portalId: portalId,
+        objectId: props?.params?.objectId,
+        id: props?.params?.id
+      };
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.FILES, params, queryParams: props?.queryParams });
+      return HttpClient.get(apiUrl);
+    },
+    details: (props = null) => {
+      const params = {
+        // hubId: config.hubId,
+        // portalId: portalId,
+        objectId: props?.params?.objectId,
+        id: props?.params?.id,
+        rowId: props?.params?.rowId
+      };
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.FILE, params, queryParams: props?.queryParams });
+      return HttpClient.get(apiUrl);
+    },
+    download: (props = null) => {
+      const params = {
+        objectId: props?.params?.objectId,
+        id: props?.params?.id,
+        rowId: props?.params?.rowId
+      };
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.FILE_DOWNLOAD, params, queryParams: props?.queryParams });
+      return HttpClient.post(apiUrl, {});
+    },
+    addFolder: async (props = null) => {
+      const params = { hubspotObjectTypeId: props?.hubspotObjectTypeId, ...props.params };
+      const queryParams = props.queryParams;
+      const payload = props.payload;
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.FILES_CREATE_FOLDER, params, queryParams });
+      const listQuery = fileStore.getState().queryParams ?? {};
+      const response = await HttpClient.post(apiUrl, payload);
+      const recordId = props?.params?.id;
+      const objectTypeId = props?.params?.objectId;
+      if (recordId && objectTypeId) {
+        purgeEngagementCaches({
+          objectTypeId,
+          recordIds: [String(recordId)],
+          views: ["files"],
+          listQuery
+        });
+      }
+      return response;
+    },
+    addFile: async (props = null) => {
+      const params = { hubspotObjectTypeId: props?.hubspotObjectTypeId, ...props.params };
+      const queryParams = props.queryParams;
+      const payload = props.payload;
+      const axiosConfig = props.config || {};
+      const apiUrl = generateApiUrl({ route: API_ENDPOINTS.FILES_UPLOAD, params, queryParams });
+      const listQuery = fileStore.getState().queryParams ?? {};
+      const response = await HttpClient.post(apiUrl, payload, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        },
+        ...axiosConfig
+      });
+      const recordId = props?.params?.id;
+      const objectTypeId = props?.params?.objectId;
+      if (recordId && objectTypeId) {
+        purgeEngagementCaches({
+          objectTypeId,
+          recordIds: [String(recordId)],
+          views: ["files"],
+          listQuery
+        });
+      }
+      return response;
+    }
+  }
+};
+
+// src/main/features/crm/client/cache-client.ts
+var cacheClient = {
+  purge: (body, headers) => {
+    const apiUrl = generateApiUrl({ route: API_ENDPOINTS.CACHE_PURGE });
+    return HttpClient.post(apiUrl, body, headers ? { headers } : void 0);
+  },
+  purgeStatus: (purgeJobId) => {
+    const apiUrl = generateApiUrl({
+      route: API_ENDPOINTS.CACHE_PURGE_STATUS,
+      params: { purgeJobId }
+    });
+    return HttpClient.get(apiUrl);
+  }
+};
+
+// src/main/features/auth/client/security-client.ts
+var refreshTokenHeaders = (refreshToken) => {
+  if (!refreshToken) {
+    return void 0;
+  }
+  return { "X-Refresh-Token": refreshToken };
+};
+var securityClient = {
+  getOverview: (query) => HttpClient.get(
+    generateApiUrl({
+      route: API_ENDPOINTS.SECURITY_OVERVIEW,
+      queryParams: portalIdQuery(query?.portalId)
+    })
+  ),
+  getLoginActivity: (query) => HttpClient.get(
+    generateApiUrl({
+      route: API_ENDPOINTS.SECURITY_LOGIN_ACTIVITY,
+      queryParams: query ?? {}
+    })
+  ),
+  getSessions: (query) => HttpClient.get(
+    generateApiUrl({
+      route: API_ENDPOINTS.SECURITY_SESSIONS,
+      queryParams: {
+        page: query?.page,
+        limit: query?.limit,
+        sort: query?.sort,
+        currentFamilyId: query?.currentFamilyId
+      }
+    }),
+    void 0,
+    mergeRequestOptions(void 0, refreshTokenHeaders(query?.refreshToken))
+  ),
+  revokeSession: (payload) => HttpClient.post(
+    generateApiUrl({
+      route: API_ENDPOINTS.SECURITY_SESSION_REVOKE,
+      params: { familyId: payload.familyId }
+    }),
+    null,
+    mergeRequestOptions(void 0, refreshTokenHeaders(payload.refreshToken))
+  ),
+  revokeOtherSessions: (refreshToken) => HttpClient.post(API_ENDPOINTS.SECURITY_SESSIONS_REVOKE_OTHERS, null, mergeRequestOptions(void 0, refreshTokenHeaders(refreshToken)))
+};
+
+// src/main/core/http/client-assembler.ts
+var Client = {
+  ...authenticationClient,
+  ...crmClient,
+  ...engagementClient,
+  cache: cacheClient,
+  mfa: mfaClient,
+  security: securityClient
+};
+
+// src/main/core/utils/cache/createCachePurgeJob.ts
+function randomIdempotencyKey() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `purge-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function mapErrorCode(status, message) {
+  if (status === 400 || status === 422) {
+    return "VALIDATION";
+  }
+  if (status === 429) {
+    return "RATE_LIMITED";
+  }
+  if (message?.toLowerCase().includes("disabled")) {
+    return "PURGE_API_DISABLED";
+  }
+  return status ? "UNKNOWN" : "NETWORK";
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function createCachePurgeJob(request, options = {}) {
+  const idempotencyKey = options.idempotencyKey ?? randomIdempotencyKey();
+  try {
+    const headers = { "Idempotency-Key": idempotencyKey };
+    const response = await Client.cache.purge(request, headers);
+    const data = response?.data;
+    const purgeJobId = data?.purgeJobId;
+    let status = data?.status;
+    if (options.waitForWarm && purgeJobId && request.warm !== false) {
+      const timeout = options.pollTimeoutMs ?? 3e4;
+      const interval = options.pollIntervalMs ?? 500;
+      const deadline = Date.now() + timeout;
+      while (Date.now() < deadline) {
+        const statusRes = await Client.cache.purgeStatus(purgeJobId);
+        const job = statusRes?.data;
+        const jobStatus = job?.status;
+        if (jobStatus === "completed") {
+          status = "completed";
+          break;
+        }
+        if (jobStatus === "failed") {
+          return {
+            ok: false,
+            purgeJobId,
+            status: "failed",
+            errorCode: "WARM_FAILED",
+            message: "Cache warm job failed"
+          };
+        }
+        await sleep(interval);
+      }
+      if (status !== "completed") {
+        return {
+          ok: false,
+          purgeJobId,
+          status: status ?? "warming",
+          errorCode: "WARM_FAILED",
+          message: "Timed out waiting for cache warm job"
+        };
+      }
+    }
+    return {
+      ok: true,
+      purgeJobId,
+      status,
+      evicted: data?.evicted,
+      warnings: data?.warnings
+    };
+  } catch (err) {
+    const axiosErr = err;
+    const status = axiosErr.response?.status;
+    const message = axiosErr.response?.data?.message ?? (err instanceof Error ? err.message : "Cache purge request failed");
+    return {
+      ok: false,
+      errorCode: mapErrorCode(status, message),
+      message
+    };
+  }
+}
+function logError(context, error) {
+  if (axios.isAxiosError(error) && error.response?.status === 401) {
+    resetAllStore();
+  }
+  logger.error(context, error);
+}
+
+// src/main/core/mutation/createMutation.ts
+function createMutation(mutationFn, options) {
+  let inFlight = 0;
+  let lastReportedLoading = null;
+  const syncLoading = () => {
+    const active = inFlight > 0;
+    if (lastReportedLoading === active) return;
+    lastReportedLoading = active;
+    options?.onLoadingChange?.(active);
+  };
+  const mutate = async (payload) => {
+    inFlight += 1;
+    syncLoading();
+    try {
+      const response = await mutationFn(payload);
+      await options?.onSuccess?.(response, payload);
+      return response;
+    } catch (error) {
+      options?.onError?.(error, payload);
+      logError("[mutation]", error);
+      throw error;
+    } finally {
+      inFlight -= 1;
+      syncLoading();
+    }
+  };
+  return {
+    mutate,
+    isLoading: () => inFlight > 0
+  };
+}
+
+export { API_ENDPOINTS, Client, HttpClient, applyContractApiDate, buildCachePurgeRequest, buildCrmListPurgeTarget, buildCrmSinglePurgeTarget, buildEngagementPurgeTarget, buildPortalConfigPurgeTarget, buildUserSessionPurgeTarget, createCachePurgeJob, createMutation, extractEngagementItemIdFromWriteResponse, extractHubspotRecordIdFromWriteResponse, generateApiUrl, getAuthRefreshToken, getConfiguredContractApiDate, getFieldErrors, getFormErrors, initializeHttpClient, mergePurgeTargets, navigationApi, purgeCrmAssociationCaches, purgeCrmCombined, purgeCrmDetailAndListAfterCrmWrite, purgeCrmListCache, purgeCrmListCacheAfterCrmWrite, purgeCrmObjectDataCache, purgeCrmRecordCache, purgeEngagementCaches, purgeEngagementCachesAfterCrmWrite, resolveCrmListPurgeQuery, resolveListTableParams, setEditorPreviewMockHandler, startVisibilityRefreshScheduler, stopVisibilityRefreshScheduler, toCachePurgeListQuery };
+//# sourceMappingURL=chunk-BXHEEGBF.js.map
+//# sourceMappingURL=chunk-BXHEEGBF.js.map