@envive-ai/react-hooks 0.3.2 → 0.3.3

package/dist/contexts/salesAgentContext/salesAgentService.js

@@ -0,0 +1,98 @@
+import { useMessageInterceptor } from "../../interceptors/useMessageInterceptor.js";
+import logger_default from "../../application/logging/logger.js";
+import { MessageType } from "../../application/models/message.js";
+import "../../application/models/index.js";
+import { appDetailsAtom } from "../../atoms/app/index.js";
+import { useFeatureFlagService } from "../featureFlagServiceContext/featureFlagServiceContext.js";
+import { messageFromResponse } from "../../application/utils/messageFromResponse.js";
+import "../../application/utils/index.js";
+import { messagesAtom, requestFailureAtom } from "../../atoms/chat/chatState.js";
+import "../featureFlagServiceContext/index.js";
+import commerce_api_default from "../../application/commerce-api.js";
+import { useCallback } from "react";
+import { v4 } from "uuid";
+import { useAtomValue, useSetAtom } from "jotai";
+
+//#region src/contexts/salesAgentContext/salesAgentService.ts
+const getQueryParam = (key) => {
+	return new URL(window.location.href).searchParams.get(key);
+};
+const updateMessageState = (message, lastMessage, setMessages) => {
+	if (lastMessage == null) {
+		setMessages((prev) => [...prev, [message]]);
+		return message;
+	}
+	if (lastMessage.type === MessageType.Text && message.type === MessageType.Text) {
+		const newMessage = {
+			...lastMessage,
+			metadata: {
+				...lastMessage.metadata,
+				content: lastMessage.metadata.content + message.metadata.content
+			}
+		};
+		setMessages((prev) => {
+			const lastTurn = prev[prev.length - 1];
+			return [...prev.slice(0, prev.length - 1), [...lastTurn.slice(0, lastTurn.length - 1), newMessage]];
+		});
+		return newMessage;
+	}
+	setMessages((prev) => [...prev.slice(0, prev.length - 1), [...prev[prev.length - 1], message]]);
+	return message;
+};
+const processStreamingResponse = async (stream, messageInterceptor, setMessages) => {
+	let lastMessage;
+	for await (const response of stream) try {
+		if (messageInterceptor.intercept(response)) return;
+		if (!response) throw new Error("No response from stream");
+		const message = messageFromResponse(response);
+		if (!message) throw new Error("Failed to transform API response to client message");
+		lastMessage = updateMessageState(message, lastMessage, setMessages);
+	} catch (error) {
+		logger_default.logWarn(`[spiffy-ai] Failed to generate responses from stream`, error, {
+			lastResponse: lastMessage,
+			response
+		});
+	}
+};
+const useSalesAgentService = () => {
+	const setRequestFailure = useSetAtom(requestFailureAtom);
+	const setMessages = useSetAtom(messagesAtom);
+	const messageInterceptor = useMessageInterceptor();
+	const featureFlagService = useFeatureFlagService();
+	const context = useAtomValue(appDetailsAtom);
+	return {
+		createResponsePayload: useCallback(({ userEvents, generationParams }) => {
+			const featureFlags = featureFlagService?.featureFlagService?.getFeatureFlags() || {};
+			const overrideConfigVersion = getQueryParam("spiffy_config_version") || getQueryParam("envive_config_version") || void 0;
+			const overrideModelDatetime = getQueryParam("override_model_datetime") || void 0;
+			return {
+				id: v4(),
+				context,
+				userEvents,
+				featureFlags,
+				generationParams,
+				overrideConfigVersion,
+				overrideModelDatetime
+			};
+		}, [context, featureFlagService?.featureFlagService]),
+		getStreamingResponses: useCallback(async (payload) => {
+			console.log("getStreamingResponses payload", JSON.stringify(payload, null, 2));
+			const stream = commerce_api_default.getNextResponseStreaming(payload);
+			try {
+				setRequestFailure(false);
+				await processStreamingResponse(stream, messageInterceptor, setMessages);
+			} catch (e) {
+				console.error("error getting streaming responses", e);
+				throw e;
+			}
+		}, [
+			setRequestFailure,
+			messageInterceptor,
+			setMessages
+		])
+	};
+};
+
+//#endregion
+export { useSalesAgentService };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"salesAgentService.js","names":["lastMessage: Message | undefined","error: unknown","useSalesAgentService: () => SalesAgentService","uuid","CommerceApiClient"],"sources":["../../../src/contexts/salesAgentContext/salesAgentService.ts"],"sourcesContent":["import { useAtomValue, useSetAtom } from 'jotai';\nimport { useCallback } from 'react';\nimport { v4 as uuid } from 'uuid';\nimport CommerceApiClient from 'src/application/commerce-api';\nimport { appDetailsAtom } from 'src/atoms/app';\nimport Logger from 'src/application/logging/logger';\nimport {\n  GenerationParams,\n  Message,\n  MessageType,\n  NextMessageRequest,\n  Response,\n  UserEvent,\n} from 'src/application/models';\nimport { messageFromResponse } from 'src/application/utils';\nimport { messagesAtom, requestFailureAtom } from 'src/atoms/chat/chatState';\nimport { useMessageInterceptor } from 'src/interceptors/useMessageInterceptor';\nimport { useFeatureFlagService } from '../featureFlagServiceContext';\n\ninterface SalesAgentService {\n  createResponsePayload: (payload: {\n    userEvents: UserEvent[];\n    generationParams?: GenerationParams;\n  }) => NextMessageRequest;\n  getStreamingResponses: (payload: NextMessageRequest) => Promise<void>;\n}\n\nexport const getQueryParam = (key: string): string | null => {\n  const urlObj = new URL(window.location.href);\n  return urlObj.searchParams.get(key);\n};\n\nconst updateMessageState = (\n  message: Message,\n  lastMessage: Message,\n  setMessages: (updater: (prev: Message[][]) => Message[][]) => void,\n): Message => {\n  if (lastMessage == null) {\n    setMessages(prev => [...prev, [message]]);\n    return message;\n  }\n  if (lastMessage.type === MessageType.Text && message.type === MessageType.Text) {\n    const newMessage = {\n      ...lastMessage,\n      metadata: {\n        ...lastMessage.metadata,\n        content: lastMessage.metadata.content + message.metadata.content,\n      },\n    };\n    setMessages(prev => {\n      const lastTurn = prev[prev.length - 1];\n      return [\n        ...prev.slice(0, prev.length - 1),\n        [...lastTurn.slice(0, lastTurn.length - 1), newMessage],\n      ];\n    });\n    return newMessage;\n  }\n  setMessages(prev => [...prev.slice(0, prev.length - 1), [...prev[prev.length - 1], message]]);\n  return message;\n};\n\nconst processStreamingResponse = async (\n  stream: AsyncIterable<Response>,\n  messageInterceptor: { intercept: (response?: Response) => boolean | undefined },\n  setMessages: (updater: (prev: Message[][]) => Message[][]) => void,\n): Promise<void> => {\n  let lastMessage: Message | undefined;\n\n  for await (const response of stream) {\n    try {\n      if (messageInterceptor.intercept(response)) {\n        return;\n      }\n\n      if (!response) {\n        throw new Error('No response from stream');\n      }\n      const message = messageFromResponse(response);\n      if (!message) {\n        throw new Error('Failed to transform API response to client message');\n      }\n\n      // No support for ChatSearch messages at the current time.\n      // Perhaps we add support back in the future\n      // if (message.type === MessageType.ProductSearch) {\n      //   handleSearchResults(message);\n      //   hasSearchResults = true;\n      //   setSearchIsLoading(false); // Update search loading immediately when results are detected\n      // }\n\n      lastMessage = updateMessageState(message, lastMessage!, setMessages);\n    } catch (error: unknown) {\n      Logger.logWarn(`[spiffy-ai] Failed to generate responses from stream`, error, {\n        lastResponse: lastMessage,\n        response,\n      });\n    }\n  }\n};\n\nexport const useSalesAgentService: () => SalesAgentService = () => {\n  const setRequestFailure = useSetAtom(requestFailureAtom);\n  const setMessages = useSetAtom(messagesAtom);\n  const messageInterceptor = useMessageInterceptor();\n\n  const featureFlagService = useFeatureFlagService();\n  const context = useAtomValue(appDetailsAtom);\n\n  const createResponsePayload = useCallback(\n    ({\n      userEvents,\n      generationParams,\n    }: {\n      userEvents: UserEvent[];\n      generationParams?: GenerationParams;\n    }): NextMessageRequest => {\n      const featureFlags = featureFlagService?.featureFlagService?.getFeatureFlags() || {};\n\n      const overrideConfigVersion =\n        getQueryParam('spiffy_config_version') ||\n        getQueryParam('envive_config_version') ||\n        undefined;\n      const overrideModelDatetime = getQueryParam('override_model_datetime') || undefined;\n      return {\n        id: uuid(),\n        context,\n        userEvents,\n        featureFlags,\n        generationParams,\n        overrideConfigVersion,\n        overrideModelDatetime,\n      };\n    },\n    [context, featureFlagService?.featureFlagService],\n  );\n\n  const getStreamingResponses = useCallback(\n    async (payload: NextMessageRequest): Promise<void> => {\n      // logPerfMetric(PerfMetricsEvents.FirstResponseStarted);\n      // const startTime = Date.now();\n      console.log('getStreamingResponses payload', JSON.stringify(payload, null, 2));\n      const stream = CommerceApiClient.getNextResponseStreaming(payload);\n\n      try {\n        setRequestFailure(false);\n\n        await processStreamingResponse(stream, messageInterceptor, setMessages);\n\n        // TODO: Add support for the Chrome Extension communication\n        // Log successful next_responses call\n        // const responseTime = Date.now() - startTime;\n        // await logBundleEvent({\n        //   level: 'info',\n        //   event: 'NEXT_RESPONSE_SUCCESS',\n        //   context: {\n        //     type: 'next_responses',\n        //     endpoint: '/v1/next_responses',\n        //     statusCode: 200,\n        //     responseTime,\n        //   },\n        // });\n      } catch (e) {\n        console.error('error getting streaming responses', e);\n        // Log failed next_responses call\n        // const responseTime = Date.now() - startTime;\n        // await logBundleEvent({\n        //   level: 'error',\n        //   event: 'NEXT_RESPONSE_FAILED',\n        //   message: `Failed to get streaming response: ${e}`,\n        //   context: {\n        //     type: 'next_responses',\n        //     endpoint: '/v1/next_responses',\n        //     responseTime,\n        //     error: e instanceof Error ? e.message : String(e),\n        //   },\n        // });\n\n        // handleStreamingError(e, setRequestFailure, setMessages);\n        throw e;\n        // } finally {\n        // logPerfMetric(PerfMetricsEvents.FirstResponseCompleted);\n      }\n    },\n    [\n      // logPerfMetric,\n      setRequestFailure,\n      messageInterceptor,\n      setMessages,\n    ],\n  );\n\n  return {\n    createResponsePayload,\n    getStreamingResponses,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;AA2BA,MAAa,iBAAiB,QAA+B;AAE3D,QADe,IAAI,IAAI,OAAO,SAAS,KAAK,CAC9B,aAAa,IAAI,IAAI;;AAGrC,MAAM,sBACJ,SACA,aACA,gBACY;AACZ,KAAI,eAAe,MAAM;AACvB,eAAY,SAAQ,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;AACzC,SAAO;;AAET,KAAI,YAAY,SAAS,YAAY,QAAQ,QAAQ,SAAS,YAAY,MAAM;EAC9E,MAAM,aAAa;GACjB,GAAG;GACH,UAAU;IACR,GAAG,YAAY;IACf,SAAS,YAAY,SAAS,UAAU,QAAQ,SAAS;IAC1D;GACF;AACD,eAAY,SAAQ;GAClB,MAAM,WAAW,KAAK,KAAK,SAAS;AACpC,UAAO,CACL,GAAG,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,EACjC,CAAC,GAAG,SAAS,MAAM,GAAG,SAAS,SAAS,EAAE,EAAE,WAAW,CACxD;IACD;AACF,SAAO;;AAET,cAAY,SAAQ,CAAC,GAAG,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,EAAE,CAAC,GAAG,KAAK,KAAK,SAAS,IAAI,QAAQ,CAAC,CAAC;AAC7F,QAAO;;AAGT,MAAM,2BAA2B,OAC/B,QACA,oBACA,gBACkB;CAClB,IAAIA;AAEJ,YAAW,MAAM,YAAY,OAC3B,KAAI;AACF,MAAI,mBAAmB,UAAU,SAAS,CACxC;AAGF,MAAI,CAAC,SACH,OAAM,IAAI,MAAM,0BAA0B;EAE5C,MAAM,UAAU,oBAAoB,SAAS;AAC7C,MAAI,CAAC,QACH,OAAM,IAAI,MAAM,qDAAqD;AAWvE,gBAAc,mBAAmB,SAAS,aAAc,YAAY;UAC7DC,OAAgB;AACvB,iBAAO,QAAQ,wDAAwD,OAAO;GAC5E,cAAc;GACd;GACD,CAAC;;;AAKR,MAAaC,6BAAsD;CACjE,MAAM,oBAAoB,WAAW,mBAAmB;CACxD,MAAM,cAAc,WAAW,aAAa;CAC5C,MAAM,qBAAqB,uBAAuB;CAElD,MAAM,qBAAqB,uBAAuB;CAClD,MAAM,UAAU,aAAa,eAAe;AAqF5C,QAAO;EACL,uBApF4B,aAC3B,EACC,YACA,uBAIwB;GACxB,MAAM,eAAe,oBAAoB,oBAAoB,iBAAiB,IAAI,EAAE;GAEpF,MAAM,wBACJ,cAAc,wBAAwB,IACtC,cAAc,wBAAwB,IACtC;GACF,MAAM,wBAAwB,cAAc,0BAA0B,IAAI;AAC1E,UAAO;IACL,IAAIC,IAAM;IACV;IACA;IACA;IACA;IACA;IACA;IACD;KAEH,CAAC,SAAS,oBAAoB,mBAAmB,CAClD;EA2DC,uBAzD4B,YAC5B,OAAO,YAA+C;AAGpD,WAAQ,IAAI,iCAAiC,KAAK,UAAU,SAAS,MAAM,EAAE,CAAC;GAC9E,MAAM,SAASC,qBAAkB,yBAAyB,QAAQ;AAElE,OAAI;AACF,sBAAkB,MAAM;AAExB,UAAM,yBAAyB,QAAQ,oBAAoB,YAAY;YAehE,GAAG;AACV,YAAQ,MAAM,qCAAqC,EAAE;AAgBrD,UAAM;;KAKV;GAEE;GACA;GACA;GACD,CACF;EAKA"}

package/dist/contexts/searchContext/searchContext.cjs

@@ -2,10 +2,10 @@ const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
 const require_logger = require('../../application/logging/logger.cjs');
 const require_enviveConfig = require('../../atoms/envive/enviveConfig.cjs');
 const require_enviveConfigContext = require('../enviveConfigContext/enviveConfigContext.cjs');
-const require_searchServiceAdapter = require('../../atoms/search/searchServiceAdapter.cjs');
 const require_sessionExceptions = require('../../types/exceptions/sessionExceptions.cjs');
 const require_unsupportedProductExceptions = require('../../types/exceptions/unsupportedProductExceptions.cjs');
 const require_useAppDetails = require('../../hooks/AppDetails/useAppDetails.cjs');
+const require_searchServiceAdapter = require('../../atoms/search/searchServiceAdapter.cjs');
 let __spiffy_ai_commerce_api_client = require("@spiffy-ai/commerce-api-client");
 let react = require("react");
 react = require_rolldown_runtime.__toESM(react);

package/dist/contexts/searchContext/searchContext.js

@@ -1,10 +1,10 @@
 import logger_default from "../../application/logging/logger.js";
 import { baseUrlAtom } from "../../atoms/envive/enviveConfig.js";
 import { useEnviveConfig } from "../enviveConfigContext/enviveConfigContext.js";
-import { clearSearchServiceFunction, setSearchServiceFunction } from "../../atoms/search/searchServiceAdapter.js";
 import { SessionRestartRequired } from "../../types/exceptions/sessionExceptions.js";
 import { UnsupportedProductException } from "../../types/exceptions/unsupportedProductExceptions.js";
 import { useAppDetails } from "../../hooks/AppDetails/useAppDetails.js";
+import { clearSearchServiceFunction, setSearchServiceFunction } from "../../atoms/search/searchServiceAdapter.js";
 import { Configuration, ResponseCategory, ResponseError, SearchApi } from "@spiffy-ai/commerce-api-client";
 import React, { createContext, useCallback, useContext, useEffect, useMemo } from "react";
 import { useAtomValue } from "jotai";

package/dist/contexts/systemSettingsContext/systemSettingsContext.d.cts

@@ -1,5 +1,5 @@
 import { GenerationParams } from "../../application/models/api/generationParams.cjs";
-import * as react2 from "react";
+import * as react0 from "react";
 import { Dispatch, ReactNode, SetStateAction } from "react";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 
@@ -16,7 +16,7 @@ interface SystemSettingsContextProviderProps {
   generationParams?: GenerationParams;
   showDebugBar?: boolean;
 }
-declare const SystemSettingsContext: react2.Context<SystemSettingsContextParams | undefined>;
+declare const SystemSettingsContext: react0.Context<SystemSettingsContextParams | undefined>;
 declare const SystemSettingsContextProvider: ({
   children,
   generationParams,

package/dist/contexts/types.cjs

@@ -47,11 +47,21 @@ var WidgetType = /* @__PURE__ */ function(WidgetType$1) {
 	WidgetType$1["NoOp"] = "NoOp";
 	return WidgetType$1;
 }(WidgetType || {});
+let WidgetTypeV3 = /* @__PURE__ */ function(WidgetTypeV3$1) {
+	WidgetTypeV3$1["SuggestionBarV3"] = "SuggestionBarV3";
+	WidgetTypeV3$1["ChatPreviewV3"] = "ChatPreviewV3";
+	WidgetTypeV3$1["SocialProofV3"] = "SocialProofV3";
+	WidgetTypeV3$1["ImagePromptCardV3"] = "ImagePromptCardV3";
+	WidgetTypeV3$1["ImageBannerV3"] = "ImageBannerV3";
+	WidgetTypeV3$1["SingleImagePromptV3"] = "SingleImagePromptV3";
+	return WidgetTypeV3$1;
+}({});
 
 //#endregion
 exports.CategoryExtractorType = CategoryExtractorType;
 exports.ColorNames = require_colorsConfig.ColorNames;
 exports.PageVariantTestType = PageVariantTestType;
 exports.WidgetType = WidgetType;
+exports.WidgetTypeV3 = WidgetTypeV3;
 exports.colorVar = require_colorsConfig.colorVar;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"types.cjs","names":[],"sources":["../../src/contexts/types.ts"],"sourcesContent":["import { ChatElementDisplayLocation } from 'src/application/models/chatElementDisplayLocation';\nimport { ColorMapping, ColorNames, colorVar } from 'src/application/models/colorsConfig';\nimport { FeatureGates } from 'src/application/models/featureGates';\nimport { CustomerServiceIntegrationMode, CustomerServiceType } from 'src/types/customerService';\nimport { GridInsertionType } from 'src/merchants/gridInsertion';\nimport { DOMInsertionType } from 'src/merchants/domInsertion';\n\nimport type {\n  PageVisitCategory,\n  SupportedEventProductCategory,\n} from '@spiffy-ai/commerce-api-client';\nimport { ChatState } from 'src/types/custservice-types';\nimport { SuggestionBarLocationForMetrics } from 'src/types/suggestionBarV2-types';\nimport { TestProps } from 'src/types/test-types';\nimport { OrgConfigFeatureGate } from 'src/application/models/api/orgConfigResults';\n\ntype ShowFloatingButtonOptions =\n  | 'always'\n  | 'after-interaction-on-mobile-always-desktop'\n  | 'after-interaction-anywhere'\n  | 'never';\n\ntype FloatingEntryPointConfig = {\n  position: 'bottom-left' | 'middle-left' | 'middle-right' | 'bottom-right';\n  expansionText?: {\n    pdp: string;\n    plp: string;\n  };\n  minimizedColor: string;\n  expandedColor: string;\n  textColor?: string;\n  showOption: ShowFloatingButtonOptions;\n  iconSVGSrc?: string;\n  iconSize?: number;\n  iconStrokeColor?: string;\n  iconFillColor?: string;\n  height?: number;\n  fontSize?: number;\n};\n\ntype WelcomeSectionVariant = 'standard' | 'outlined';\n\ntype WelcomeSectionColorVariant = 'standard' | 'accent' | 'brand' | 'light';\n\ntype WelcomeSectionConfig = {\n  variant: WelcomeSectionVariant;\n  colorVariant?: WelcomeSectionColorVariant;\n  title?: string;\n  subtitle?: string;\n  // icon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;\n  /* Serializable icon name that maps to a React component. Preferred over icon for database storage. */\n  iconName?: string;\n  imageSrc?: string;\n};\n\ntype ChatPreviewConfig = {\n  variant: 'flat' | 'filled' | 'outlined';\n  largeProductComparison?: boolean;\n  filledBackgroundColor: string;\n  iconFillColor: string;\n  buttonTextColor?: string;\n  buttonTextSecondaryColor?: string;\n  buttonTextHoverColor?: string;\n  buttonBackgroundColor: string;\n  buttonBackgroundHoverColor: string;\n  buttonBorderColor?: string;\n  buttonBorderHoverColor?: string;\n  copies: { pdp: string[]; plp: string[] };\n  staticSuggestionCopies?: { pdp: string[]; plp: string[] };\n  staticPLPImages?: string[];\n  footerConfig?: ChatPreviewFooterConfig;\n  headerConfig?: ChatPreviewHeaderConfig;\n  topMargin?: number;\n};\n\ntype ChatPreviewHeaderConfig = {\n  title?: string;\n  imageSrc?: string;\n  imageHeight?: number;\n  sparklesColor?: string; // used by: spanx, uniqueVintage, dreamlandBaby\n  fontSize?: string;\n  iconWidth?: string;\n  iconHeight?: string;\n};\n\ninterface ChatPreviewFooterConfig {\n  hasFade?: boolean; // used by: spanx, uniqueVintage\n  suggestionButtonVariant?: 'dark' | 'light' | 'outlined';\n  suggestionsBackground?: string; // used by: carbahn\n  replyButtonIcon?: 'send' | 'magnifyingGlass' | 'thinMagnifyingGlass' | 'searchIcon';\n  replyButtonText?: string;\n  replyInputHasShadow?: boolean; // used by: spanx\n  replyInputHasBorder?: boolean; // used by: spanx\n  backgroundColor?: string; // used by spanx, tushbaby, will need custom CSS when switching over\n}\n\ntype ProductReviewStyleVariant = 'standard' | 'bordered';\n\ntype ProductReviewColorVariant = 'neutral' | 'brand' | 'premium';\n\ninterface ProductReviewConfig {\n  styleVariant: ProductReviewStyleVariant;\n  colorVariant: ProductReviewColorVariant;\n  verifiedBuyerTitle: string;\n  incentivizedReviewFlag?: boolean;\n}\n\ntype PageCardVariant = 'filled' | 'outlined' | 'minimal';\n\ntype PageCardHoverVariant = 'none' | 'shadow' | 'lift';\n\ntype PageCardIconVariant = 'primary' | 'accent' | 'background' | 'none';\n\ntype PageCardConfig = {\n  variant: PageCardVariant;\n  hoverVariant: PageCardHoverVariant;\n  iconVariant: PageCardIconVariant;\n};\n\ntype ProductCardVariant = 'filled' | 'bordered' | 'minimal' | 'transparentBordered';\n\ntype ProductCardHoverVariant = 'backgroundDark' | 'none';\n\ntype ProductCardLayoutVariant = 'normal' | 'tall' | 'square';\n\ninterface ProductCardConfig {\n  variant: ProductCardVariant;\n  hoverVariant: ProductCardHoverVariant;\n  layoutVariant: ProductCardLayoutVariant;\n  pricePrefix?: string;\n}\n\ntype CSSwitchConfig = {\n  variant: 'attached' | 'detached';\n  backgroundColor: string;\n  borderColor: string;\n  selectedTextColor: string;\n  selectedBackgroundColor?: string;\n  unselectedTextColor: string;\n  unselectedBackgroundColor?: string;\n  supportTitle?: string;\n  spiffyTitle?: string;\n  spiffyTitleHasLogo?: boolean;\n};\n\ntype ChatHeaderConfig = {\n  collapsedColor: string;\n  expandedColor: string;\n  chevronColor: string;\n  imageSrc?: string;\n  icon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;\n  closeIcon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;\n  borderBottom?: string;\n  headerBarHeightPartialView: number;\n  headerBarHeightFullView: number;\n  customerSupportSwitchConfig?: CSSwitchConfig;\n};\n\ntype SimpleCustomerServiceIntegration = {\n  integrationMode: CustomerServiceIntegrationMode;\n  provider: CustomerServiceType;\n  useUnifiedButton?: boolean;\n  maxfileUploadSize?: number;\n};\n\ntype FullCustomerServiceIntegration = {\n  integrationMode: CustomerServiceIntegrationMode;\n  provider: CustomerServiceType;\n  useUnifiedButton?: boolean;\n  chatEnabledDuringBusinessHours?: boolean;\n  showNameInput?: boolean;\n  formAiName?: string;\n  welcomeTitle: string;\n  welcomeDescription: string;\n  showWelcomeOnForm?: boolean;\n  contactSubjectOptions?: string[];\n  getCustomWaitingMessage?: (name?: string) => string;\n  withinBusinessHoursMessage?: string;\n  withinBusinessHoursWaitingMessage?: string;\n  outsideBusinessHoursMessage?: string;\n  outsideBusinessHoursWaitingMessage?: string;\n  withinBusinessHoursFormMessage?: string;\n  outsideBusinessHoursFormMessage?: string;\n  suggestedAIQuestions?: string[];\n  businessHoursPolling?: number;\n  maxfileUploadSize?: number;\n\n  /**\n   * @deprecated This is handled by the BE.\n   */\n  businessHoursStartUTC?: string;\n  /**\n   * @deprecated This is handled by the BE.\n   */\n  businessHoursEndUTC?: string;\n  /**\n   * @deprecated This is handled by the BE.\n   */\n  businessHoursTimezone?: string;\n\n  showAISuggestionsWithinBusinessHours?: boolean;\n  waitingMessagePosition?: 'BEFORE_MESSAGES' | 'AFTER_MESSAGES';\n  legalMessage?: string;\n  withinBusinessHoursInitialState?: ChatState;\n  outsideBusinessHoursInitialState?: ChatState;\n  withinBusinessHoursButtontext?: string;\n  outsideBusinessHoursButtontext?: string;\n  reopenChatMessage: string;\n};\n\ntype CustomerServiceIntegration = SimpleCustomerServiceIntegration | FullCustomerServiceIntegration;\n\ntype ConversationalSeach = {\n  enabled?: boolean;\n  replyInput?: ReplyInputConfig;\n  suggestions?: string[];\n  entrypointBgColor?: string;\n  entrypointTextColor?: string;\n  entrypointBtnColor?: string;\n  entrypointBtnTextColor?: string;\n  entrypointBtnBorderColor?: string;\n  entrypointContainer?: string;\n  entrypointTrigger?: string;\n  productGridContainer?: string;\n  generalSearchBtn?: string;\n  pageContent?: string;\n  searchContent?: string;\n  sortingTitle?: string;\n  selectionTitle?: string;\n  sortingFont?: string;\n  optionsFont?: string;\n  sortingButtonText?: string;\n};\n\ntype ChatMessageVariant = 'standard' | 'premium' | 'accent';\n\ninterface ChatMessageConfig {\n  assistantChatTitle: string;\n  variant: ChatMessageVariant;\n  productLink: {\n    variant: ProductLinkVariant;\n    hoverVariant: ProductLinkHoverVariant;\n    iconVariant: ProductLinkIconVariant;\n  };\n}\n\ninterface ReplyInputConfig {\n  // TODO consider making this a number\n  size?: 'md' | 'lg';\n  sendIcon: 'arrowUp' | 'send' | 'search';\n  placeholder?: string;\n}\n\ninterface PartialViewConfig {\n  // maximum height of the partial view as a percentage of the screen height\n  maxHeight: number;\n  borderRadius?: string;\n}\n\ntype ProductLinkIconVariant =\n  | 'accentPrimary'\n  | 'backgroundPrimary'\n  | 'backgroundPrimaryDark'\n  | 'borderLight'\n  | 'backgroundSaturated';\n\ntype ProductLinkVariant = 'textLink';\n\ntype ProductLinkHoverVariant = 'backgroundDark';\n\ntype SearchCardVariant =\n  | 'backgroundPrimary'\n  | 'backgroundSecondary'\n  | 'backgroundSecondaryDark'\n  | 'backgroundLight'\n  | 'backgroundSaturated';\n\ntype SuggestionButtonVariant =\n  | 'outlined'\n  | 'outlinedLight'\n  | 'primary'\n  | 'secondary'\n  | 'tertiary'\n  | 'dark'\n  | 'darkAccent'\n  | 'darkPrimary'\n  | 'secondaryDark'\n  | 'secondaryAccent'\n  | 'transparent'\n  | 'transparentDark'\n  | 'lightDark';\n\ninterface SuggestionButtonConfig {\n  variant?: SuggestionButtonVariant;\n  hoverVariant?: SuggestionButtonVariant;\n  answerVariant?: SuggestionButtonVariant;\n  borderRadius?: 'sm' | 'md' | 'lg';\n}\n\ntype NumRows = 'default' | 'alwaysOneRow' | 'alwaysTwoRows' | 'twoRowsOnMobile';\n\ninterface AlphabeticFilterSorting {\n  type: 'alphabetic';\n}\ninterface ProductCountFilterSorting {\n  type: 'productCount';\n}\ninterface CustomFilterSorting {\n  type: 'custom';\n  map: Record<string, number>;\n}\n\ntype FilterSorting = AlphabeticFilterSorting | ProductCountFilterSorting | CustomFilterSorting;\n\ninterface BaseFilterConfig {\n  filterId: string;\n  displayName: string;\n}\ninterface DynamicFilterConfig extends BaseFilterConfig {\n  type: 'dynamic';\n  attribute: string;\n  sorting: FilterSorting;\n}\n\ninterface PriceFilterConfig extends BaseFilterConfig {\n  type: 'price';\n  bucketSize: number;\n}\n\nexport type FilterAttribute = DynamicFilterConfig | PriceFilterConfig;\n\nexport type SearchZeroStateVariant = 'backgroundTertiary' | 'backgroundDark' | 'backgroundPrimary';\nexport type SearchZeroStateLayout = 'input' | 'icon';\n\nexport type SearchInputVariant = 'standard';\n\nexport type SearchIconVariant = 'thin' | 'bold';\n\nexport type SearchFilterSidebarVariant = 'darkButton' | 'lightButton';\n\nexport type ProductGridVariant = 'standard' | 'square';\n\ntype UserQueryButtonIcon =\n  | 'magnifyingGlass'\n  | 'send'\n  | 'magnifyingGlassThin'\n  | 'sendArrow'\n  | 'searchIcon';\n\ninterface UserQueryButtonConfig {\n  variant?: 'box' | 'underlineLight' | 'underlineDark';\n  placeholderText?: string;\n  icon: UserQueryButtonIcon;\n}\n\n// TODO: this should be included in the top-level widget config\ninterface TermsAndConditionsConfig {\n  copy: string;\n  link: string;\n  linkText: string;\n}\n\ninterface MerchantVariantSettings {\n  dynamicVariants: {\n    enabled: boolean; // This feature will enable dynamic variants for the merchant. Useful for SPA's\n    refreshInterval?: number; // The interval in milliseconds to check for changes in the URL\n  };\n}\n\ninterface FloatingChatConfig {\n  enableWatermark: boolean;\n  userQueryInputEnabled: boolean;\n  ignoreFirstModelResponse?: boolean;\n  neverShowSingleProductCards?: boolean;\n  termsAndConditionsConfig?: TermsAndConditionsConfig;\n\n  // Footer config\n  suggestionButtonConfig?: SuggestionButtonConfig;\n  replyInputConfig: ReplyInputConfig;\n}\n\ninterface SearchConfig {\n  enableGlobalSearch: boolean;\n  searchFilterConfig: FilterAttribute[];\n  searchOverlayHeading?: string;\n  redirectSearchResultsUrl?: string;\n  additiveDynamicFilters?: boolean;\n  recommendedProducts?: string[];\n  recommendedProductsHeading?: string;\n}\n\ntype OrgUIConfig = {\n  shortName: string;\n  id?: string;\n  floatingEntrypointConfig?: FloatingEntryPointConfig;\n  // Deprecated - remove with ChatPreview rewrite\n  chatPreviewConfig?: ChatPreviewConfig;\n\n  customerServiceIntegration: CustomerServiceIntegration;\n  // Deprecated - remove when Global Search is fully launched\n  conversationalSearch?: ConversationalSeach;\n\n  merchantOverrideCss?: string;\n\n  // Deprecated TODO: Remove this deprecated value when Groove CX has proper unified button support\n  // selectors for elements that should be hidden when the chat is open\n  // e.g. CS widgets with max z-index (\"div[id*='cs-container']\")\n  hiddenElementSelectors?: string[];\n\n  merchantVariantSettings?: MerchantVariantSettings;\n  // TODO: Migrate all floating chat config into this top-level key\n  //\n  floatingChatConfig: FloatingChatConfig;\n\n  // Contain all search config here\n  searchConfig: SearchConfig;\n  // TODO: Move these into FloatingChatConfig\n  // Chat Header related values\n  chatHeader: ChatHeaderConfig;\n  stickyAgentSwitchSuggestion?: boolean;\n  partialViewConfig: PartialViewConfig;\n  welcomeSectionConfig?: WelcomeSectionConfig;\n  // Different response values\n  productCardConfig?: ProductCardConfig;\n  productReviewConfig?: ProductReviewConfig;\n  pageCardConfig?: PageCardConfig;\n  chatMessageConfig: ChatMessageConfig;\n};\n\ntype InsertionPoint = {\n  selector: string;\n  // this is the index of the target element, 0 if missing\n  selectionIndex?: number;\n  insertionType: DOMInsertionType;\n};\n\ntype URLTest = 'shopify' | 'null';\n\ntype IdExtractor =\n  | 'shopify-product-id'\n  | 'shopify-collection-id'\n  | 'shopify-product-variant-id'\n  | 'url-resolver-product-id'\n  | 'url-resolver-plp-id'\n  | 'null';\n\n// This contains a map between PageVisitCategory and a list of URL's that are classified as the value\nenum CategoryExtractorType {\n  VisitCategoryMap = 'VisitCategoryMap',\n  VisitCategoryDefault = 'VisitCategoryDefault',\n}\n\ninterface BaseCategoryExtractor<T extends CategoryExtractorType> {\n  type: T;\n}\n\n// This map betweens a category and a list of url patterns\ninterface VisitCategoryMap extends BaseCategoryExtractor<CategoryExtractorType.VisitCategoryMap> {\n  map: {\n    [key in PageVisitCategory]?: string[];\n  };\n}\n\n// This will return a hard-coded default PageVisitCategory. It is intended to be used by fallback page types\ninterface VisitCategoryDefault extends BaseCategoryExtractor<CategoryExtractorType.VisitCategoryDefault> {\n  value: PageVisitCategory;\n}\n\ntype CategoryExtractor = VisitCategoryMap | VisitCategoryDefault;\n\ntype WrappingElement = {\n  className: string;\n  element: string;\n  insertionType: DOMInsertionType;\n};\n\nenum PageVariantTestType {\n  ShopifyPLP = 'ShopifyPLP',\n  ShopifyPDP = 'ShopifyPDP',\n  PageCategory = 'PageCategory',\n  CatalogCategory = 'CatalogCategory',\n  TopCatalogCategory = 'TopCatalogCategory',\n  HasReviews = 'HasReviews',\n  InCollection = 'InCollection',\n  HasMerchantTag = 'HasMerchantTag',\n  FeatureGate = 'FeatureGate',\n  PlpId = 'PlpId',\n  QueryParam = 'QueryParam',\n  ProductId = 'ProductId',\n  UserHasInteracted = 'UserHasInteracted',\n  UserHasNotInteracted = 'UserHasNotInteracted',\n  isLoading = 'isLoading',\n  isProductComparison = 'isProductComparison',\n  Fallback = 'Fallback',\n  UrlResolver = 'UrlResolver',\n  Null = 'null',\n}\n\ninterface BasePageVariantTest<T extends PageVariantTestType> {\n  testType: T;\n}\n\ninterface TopCatalogCategory extends BasePageVariantTest<PageVariantTestType.TopCatalogCategory> {\n  topCategory: string[];\n}\n\ninterface CatalogCategoryTest extends BasePageVariantTest<PageVariantTestType.CatalogCategory> {\n  category: SupportedEventProductCategory;\n}\n\ninterface HasReviewsTest extends BasePageVariantTest<PageVariantTestType.HasReviews> {\n  reviewMinimum?: number;\n}\n\n// This will return true if the product is in any of the listed collections\ninterface InCollectionTest extends BasePageVariantTest<PageVariantTestType.InCollection> {\n  collections: string[];\n}\n\n// This will return true if the product has any of the listed merchant tags\ninterface HasMerchantTagTest extends BasePageVariantTest<PageVariantTestType.HasMerchantTag> {\n  merchantTags: string[];\n}\n\ninterface ShopifyPLPURLTest extends BasePageVariantTest<PageVariantTestType.ShopifyPLP> {}\n\ninterface ShopifyPDPURLTest extends BasePageVariantTest<PageVariantTestType.ShopifyPDP> {}\n\ninterface PageCategoryTest extends BasePageVariantTest<PageVariantTestType.PageCategory> {\n  extractor: CategoryExtractor;\n}\n\ninterface FeatureGateTest extends BasePageVariantTest<PageVariantTestType.FeatureGate> {\n  featureGate: FeatureGates;\n}\n\ninterface ProductIdTest extends BasePageVariantTest<PageVariantTestType.ProductId> {\n  productIdExtractor: IdExtractor;\n  productIds: string[];\n}\n\ninterface PlpIdTest extends BasePageVariantTest<PageVariantTestType.PlpId> {\n  plpIdExtractor: IdExtractor;\n  plpIds: string[];\n}\n\ninterface QueryParamTest extends BasePageVariantTest<PageVariantTestType.QueryParam> {\n  queryParam: string;\n}\n\ninterface UserHasInteractedTest extends BasePageVariantTest<PageVariantTestType.UserHasInteracted> {}\n\ninterface UserHasNotInteractedTest extends BasePageVariantTest<PageVariantTestType.UserHasNotInteracted> {}\n\ninterface IsLoadingTest extends BasePageVariantTest<PageVariantTestType.isLoading> {}\n\ninterface IsProductComparison extends BasePageVariantTest<PageVariantTestType.isProductComparison> {}\n\ninterface PageFallbackTest extends BasePageVariantTest<PageVariantTestType.Fallback> {}\n\ninterface UrlResolverTest extends BasePageVariantTest<PageVariantTestType.UrlResolver> {}\n\nexport type PageVariantTest =\n  | PageCategoryTest\n  | ShopifyPLPURLTest\n  | ShopifyPDPURLTest\n  | CatalogCategoryTest\n  | TopCatalogCategory\n  | HasReviewsTest\n  | InCollectionTest\n  | HasMerchantTagTest\n  | FeatureGateTest\n  | ProductIdTest\n  | PlpIdTest\n  | QueryParamTest\n  | UserHasInteractedTest\n  | UserHasNotInteractedTest\n  | IsLoadingTest\n  | IsProductComparison\n  | PageFallbackTest\n  | UrlResolverTest;\n\n/**\n * Configuration for the social proof embedded widget\n *\n * @param headerTitle - The title text to display in the widget header\n * @param staticSuggestions - A list of strings to display as suggestions in the widget\n * @param suggestionButtonVariantDefault - The variant of the suggestion button to display in the widget footer\n * @param suggestionButtonVariantAccent - The variant of the suggestion button to display in the widget body\n * @param staticImageIndex - Index of the imageUrl to use from the product response\n */\ninterface SocialProofConfig {\n  customerQuery: string;\n  headerTitle: string;\n  staticPLPImagesLayout?: 'grid' | 'horizontal';\n  headerFontFamily?: string;\n  staticPLPImageNames?: string[];\n  staticImageIndex?: number;\n  suggestionButtonStrings: string[];\n  suggestionButtonVariantDefault: SuggestionButtonVariant;\n  suggestionButtonVariantAccent?: SuggestionButtonVariant;\n  suggestionButtonDataAttributes?: Record<string, string>;\n  userQueryButtonConfig?: UserQueryButtonConfig;\n  logoName?: string;\n}\n\n/**\n * Configuration for creating the mount point for a widget\n *\n * @param className - Optional class name to apply to the mount point. Tailwind classes are supported\n * and encouraged. Use this parameter to style the mounting container for the widget.\n */\nexport type WidgetMountingConfig = {\n  mountingConfigId: string;\n  containerId: string;\n  testId: string;\n  parentInsertionPoint?: InsertionPoint;\n  insertionPoint: InsertionPoint;\n  gridInsertionType?: GridInsertionType;\n  wrappingElement?: WrappingElement;\n  divCheckSelector?: string;\n  suppressionSelector?: string;\n  style?: Partial<CSSStyleDeclaration>;\n  className?: string;\n  dataAttributes?: Record<string, string>;\n};\n\ntype StaticWidgetMounting = {\n  mountingConfigId: string;\n  widgetConfigId: string;\n};\ntype DynamicWidgetMounting = {\n  mountingConfigId: string;\n  mountingPointWidgets: WidgetDisplayTests[];\n};\n\ntype WidgetDisplayTests = {\n  tests: PageVariantTest[];\n  widgetConfigId: string;\n};\n\ntype WidgetMounting = StaticWidgetMounting | DynamicWidgetMounting;\n\nenum WidgetType {\n  ChatPreview = 'ChatPreview',\n  SocialProofV2 = 'SocialProofV2',\n  ChatPreviewV2 = 'ChatPreviewV2',\n  ChatPreviewIsLoading = 'ChatPreviewIsLoading',\n  ChatPreviewPostInteraction = 'ChatPreviewPostInteraction',\n  ChatPreviewProductComparison = 'ChatPreviewProductComparison',\n  SuggestionBar = 'SuggestionBar',\n  SuggestionBarV2 = 'SuggestionBarV2',\n  ImagePromptCard = 'ImagePromptCard',\n  ImageBanner = 'ImageBanner',\n  SingleImagePrompt = 'SingleImagePrompt',\n  SearchPrompt = 'SearchPrompt',\n  SearchZeroStateEntryPoint = 'SearchZeroStateEntryPoint',\n  SearchResultsEntryPoint = 'SearchResultsEntryPoint',\n  SearchOverlayHost = 'SearchOverlayHost',\n  NoOp = 'NoOp',\n}\n\ntype WidgetConfig =\n  | ChatPreviewWidgetConfig\n  | SocialProofV2WidgetConfig\n  | ChatPreviewV2WidgetConfig\n  | ChatPreviewPostInteractionWidgetConfig\n  | ChatPreviewIsLoadingWidgetConfig\n  | ChatPreviewProductComparisonWidgetConfig\n  | SuggestionBarWidgetV2Config\n  | ImagePromptWidgetConfig\n  | ImageBannerWidgetConfig\n  | SingleImagePromptWidgetConfig\n  | SearchPromptWidgetConfig\n  | SearchEntryPointWidgetConfig\n  | SearchResultsEntryPointWidgetConfig\n  | SearchOverlayHostWidgetConfig\n  | NoOpWidgetConfig;\n\ninterface BaseWidgetConfig<T extends WidgetType> {\n  widgetConfigId: string;\n  type: T;\n  contentId?: string;\n}\n\ninterface ImageBannerWidgetConfig extends BaseWidgetConfig<WidgetType.ImageBanner> {\n  imageSrc: string;\n  title: string;\n  subtitle: string;\n  assistantMessage: string;\n}\n\ninterface ChatPreviewWidgetConfig extends BaseWidgetConfig<WidgetType.ChatPreview> {\n  variant: 'filled' | 'flat' | 'outlined';\n  addSeparators?: boolean;\n  socialProofConfig?: SocialProofConfig;\n  footerConfig?: ChatPreviewFooterConfig;\n}\n\ninterface ChatPreviewHeaderV2Config {\n  title?: string; // Default: 'Shopping Assistant'\n  imageSrc?: string;\n  imageHeight?: number;\n}\n\ntype SingleImageConfig = {\n  layout: 'single';\n  imageIndex: number;\n};\ntype MultiImageConfig = {\n  layout: 'grid' | 'horizontal';\n  imageNames: string[];\n};\ntype SocialProofImageConfig = SingleImageConfig | MultiImageConfig;\n\ntype ChatPreviewSuggestionButtonConfig = {\n  buttonStrings: string[];\n  accentButtonVariants?: {\n    button: SuggestionButtonVariant;\n    hover: SuggestionButtonVariant;\n  };\n  buttonVariants: {\n    button: SuggestionButtonVariant;\n    hover: SuggestionButtonVariant;\n  };\n  numRows?: NumRows;\n};\n\ntype ChatPreviewAnimatedTextConfig = {\n  leadingText: string;\n  animatedStrings: string[];\n};\n\ntype ChatPreviewVariant =\n  | { variant: 'flat' }\n  | { variant: 'filled'; backgroundFillColor: string }\n  | { variant: 'outlined' };\n\n// Base interface for common chat preview properties\ninterface BaseChatPreviewConfig {\n  headerConfig: ChatPreviewHeaderV2Config;\n  suggestionButtonsConfig: ChatPreviewSuggestionButtonConfig;\n  userQueryButtonConfig: UserQueryButtonConfig;\n  chatPreviewVariant: ChatPreviewVariant;\n  addSeparators?: boolean;\n}\n\n// Specific chat preview widget configurations\ninterface ChatPreviewPostInteractionWidgetConfig\n  extends BaseWidgetConfig<WidgetType.ChatPreviewPostInteraction>, BaseChatPreviewConfig {\n  chatPreviewVariant: ChatPreviewVariant;\n  addSeparators?: boolean;\n}\n\ninterface ChatPreviewIsLoadingWidgetConfig\n  extends BaseWidgetConfig<WidgetType.ChatPreviewIsLoading>, BaseChatPreviewConfig {}\n\ninterface ChatPreviewProductComparisonWidgetConfig\n  extends BaseWidgetConfig<WidgetType.ChatPreviewProductComparison>, BaseChatPreviewConfig {\n  useLargeProductComparison?: boolean;\n}\n\ninterface ChatPreviewV2WidgetConfig\n  extends BaseWidgetConfig<WidgetType.ChatPreviewV2>, BaseChatPreviewConfig {\n  animatedTextConfig: ChatPreviewAnimatedTextConfig;\n}\n\ninterface SocialProofV2WidgetConfig\n  extends BaseWidgetConfig<WidgetType.SocialProofV2>, BaseChatPreviewConfig {\n  customerQuery?: string; // Default: 'asked which products are the best'\n  imageConfig: SocialProofImageConfig;\n}\n\ninterface SuggestionBarWidgetV2Config extends BaseWidgetConfig<WidgetType.SuggestionBarV2> {\n  metricDisplayLocation: ChatElementDisplayLocation;\n  location: SuggestionBarLocationForMetrics;\n  variant: SuggestionButtonVariant;\n  hoverVariant: SuggestionButtonVariant;\n  buttonTexts: {\n    default: string[];\n    productSpecific?: { [productId: string]: string[] };\n  };\n  boldFirstButton?: boolean;\n  twoRowsOnMobile?: boolean;\n  animationSpeed?: 'standard' | 'slow' | 'none';\n  buttonBorderRadius?: 'sm' | 'md' | 'lg';\n}\n\ninterface ImagePromptWidgetConfig extends BaseWidgetConfig<WidgetType.ImagePromptCard> {\n  url: string;\n  lightText?: boolean;\n  title: string;\n  subtitle: string[];\n  staticSuggestionCopies: string[];\n  userQueryButtonConfig: UserQueryButtonConfig;\n  fallbackBackgroundColor?: string;\n}\n\ninterface SingleImagePromptWidgetConfig extends BaseWidgetConfig<WidgetType.SingleImagePrompt> {\n  title: string;\n  staticSuggestionCopies: string[];\n  userQueryButtonConfig: UserQueryButtonConfig;\n}\n\ninterface SearchEntryPointWidgetConfig extends BaseWidgetConfig<WidgetType.SearchZeroStateEntryPoint> {\n  searchZeroStateVariant: SearchZeroStateVariant;\n  searchInputVariant: SearchInputVariant;\n  searchIconVariant?: SearchIconVariant;\n  searchIconSize?: number;\n  suggestionButtonConfig: SuggestionButtonConfig;\n  layout: SearchZeroStateLayout;\n  searchBoxPlaceholder: string;\n  animationSpeed?: 'standard' | 'slow' | 'none';\n  compactLabel?: string;\n  initialSuggestions?: string[];\n  usingPortal?: boolean;\n  includeSubtitle?: boolean;\n}\n\ninterface NoOpWidgetConfig extends BaseWidgetConfig<WidgetType.NoOp> {}\ninterface SearchOverlayHostWidgetConfig extends BaseWidgetConfig<WidgetType.SearchOverlayHost> {}\n\ninterface SearchResultsEntryPointWidgetConfig extends BaseWidgetConfig<WidgetType.SearchResultsEntryPoint> {\n  searchInputVariant: SearchInputVariant;\n  searchFilterSidebarVariant: SearchFilterSidebarVariant;\n  productGridVariant: ProductGridVariant;\n  searchBoxPlaceholder: string;\n  noResultsFoundText?: string;\n}\n\nexport interface WidgetHeaderProps extends TestProps {\n  title?: string;\n  logo?: string;\n  logoHeight?: number;\n  orgShortName: string;\n  variant?: SearchPromptVariant;\n}\n\nexport interface UserQueryOptions {\n  footerVariant?: 'standard';\n  replyButtonText?: string;\n  replyButtonIcon?: 'magnifyingGlass' | 'send' | 'thinMagnifyingGlass' | 'ai-search';\n}\n\ntype SearchPromptVariant = 'primary';\ninterface SearchPromptWidgetConfig extends BaseWidgetConfig<WidgetType.SearchPrompt> {\n  variant: SearchPromptVariant;\n  title: string;\n  headerConfig: WidgetHeaderProps;\n  suggestionButtons: {\n    variant: SuggestionButtonVariant;\n    hoverVariant: SuggestionButtonVariant;\n    buttonTexts: string[];\n  };\n  footerConfig?: UserQueryOptions;\n}\n\ntype PageVariantBase = {\n  // Unique identifier for each entry within the pageVariants.\n  // Useful to differentiate which variant is loaded when there are multiples of a single type.\n  variantId: string;\n  widgetMounting: WidgetMounting[];\n  variantTests: PageVariantTest[];\n};\n\ntype PLPPageVariant = PageVariantBase & {\n  variantType: 'plp';\n  plpIdExtractor: IdExtractor;\n};\n\ntype PDPPageVariant = PageVariantBase & {\n  variantType: 'pdp';\n  parentProductIdExtractor?: IdExtractor;\n  productIdExtractor: IdExtractor;\n};\n\ntype VisitPageVariant = PageVariantBase & {\n  variantType: 'page_visit';\n};\n\ntype OtherPageVariant = PageVariantBase & {\n  variantType: 'other';\n};\n\ntype HomePageVariant = PageVariantBase & {\n  variantType: 'homepage';\n};\n\ntype SearchPageVariant = PageVariantBase & {\n  variantType: 'search';\n};\n\nexport type PageVariantConfig =\n  | PLPPageVariant\n  | PDPPageVariant\n  | VisitPageVariant\n  | OtherPageVariant\n  | HomePageVariant\n  | SearchPageVariant;\n\nexport type OrgPageConfig = {\n  // pageVariants is a list of page variants that we support.\n  pageVariants: PageVariantConfig[];\n  // widgetConfigs is a named set of widget configs\n  widgetConfigs: Record<string, WidgetConfig>;\n  mountingConfigs: Record<string, WidgetMountingConfig>;\n};\n\nexport type OrgConfig = OrgUIConfig;\n\nexport { CategoryExtractorType, ColorNames, colorVar, PageVariantTestType, WidgetType };\n\nexport interface EnviveConfig {\n  amplitudeApiKey?: string;\n  dataResidency?: string;\n  env?: string;\n  baseUrl?: string;\n  reactAppName?: string;\n  cdnUrl?: string;\n  contextSource?: string;\n  orgLevelApiKey?: string;\n  orgShortName?: string;\n  identifyingPrefix?: string;\n  featureOverrides?: Record<string, boolean>;\n  variantUrlOverride?: string;\n  variantInfoOverride?: any;\n  show?: boolean;\n  publicKey?: string;\n  featureGates?: OrgConfigFeatureGate[];\n}\n\nexport type {\n  CategoryExtractor,\n  ChatMessageVariant,\n  ChatMessageConfig,\n  ChatPreviewConfig,\n  ChatPreviewIsLoadingWidgetConfig,\n  ChatPreviewPostInteractionWidgetConfig,\n  ChatPreviewProductComparisonWidgetConfig,\n  ChatPreviewSuggestionButtonConfig,\n  SocialProofV2WidgetConfig,\n  ChatPreviewHeaderV2Config,\n  ChatPreviewV2WidgetConfig,\n  ChatPreviewFooterConfig,\n  ChatPreviewHeaderConfig,\n  ChatPreviewWidgetConfig,\n  ChatPreviewVariant,\n  ColorMapping,\n  CustomerServiceIntegration,\n  FloatingEntryPointConfig,\n  FullCustomerServiceIntegration,\n  IdExtractor,\n  ImageBannerWidgetConfig,\n  ImagePromptWidgetConfig,\n  InsertionPoint,\n  MultiImageConfig,\n  OrgUIConfig,\n  PageCardConfig,\n  PageCardVariant,\n  PageCardHoverVariant,\n  PageCardIconVariant,\n  ProductCardConfig,\n  ProductCardVariant,\n  ProductCardLayoutVariant,\n  ProductCardHoverVariant,\n  ProductLinkHoverVariant,\n  ProductLinkIconVariant,\n  ProductLinkVariant,\n  ProductReviewConfig,\n  ProductReviewStyleVariant,\n  ProductReviewColorVariant,\n  SearchPromptVariant,\n  SearchPromptWidgetConfig,\n  SearchResultsEntryPointWidgetConfig,\n  ShowFloatingButtonOptions,\n  SingleImagePromptWidgetConfig,\n  SearchEntryPointWidgetConfig,\n  SearchOverlayHostWidgetConfig,\n  SocialProofConfig,\n  SuggestionBarWidgetV2Config,\n  SuggestionButtonConfig,\n  SuggestionButtonVariant,\n  URLTest,\n  UserQueryButtonConfig,\n  UserQueryButtonIcon,\n  WelcomeSectionConfig,\n  WelcomeSectionVariant,\n  WelcomeSectionColorVariant,\n  WidgetConfig,\n  WrappingElement,\n  SearchCardVariant,\n  WidgetDisplayTests,\n  NoOpWidgetConfig,\n  WidgetMounting,\n  StaticWidgetMounting,\n  DynamicWidgetMounting,\n  PDPPageVariant,\n  PLPPageVariant,\n  VisitPageVariant,\n  OtherPageVariant,\n  HomePageVariant,\n  SearchPageVariant,\n  NumRows,\n};\n"],"mappings":";;;AA+bA,IAAK,0EAAL;AACE;AACA;;EAFG;AA6BL,IAAK,sEAAL;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;EAnBG;AAuKL,IAAK,oDAAL;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;EAhBG"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"types.cjs","names":[],"sources":["../../src/contexts/types.ts"],"sourcesContent":["import { ChatElementDisplayLocation } from 'src/application/models/chatElementDisplayLocation';\nimport { ColorMapping, ColorNames, colorVar } from 'src/application/models/colorsConfig';\nimport { FeatureGates } from 'src/application/models/featureGates';\nimport { CustomerServiceIntegrationMode, CustomerServiceType } from 'src/types/customerService';\nimport { GridInsertionType } from 'src/merchants/gridInsertion';\nimport { DOMInsertionType } from 'src/merchants/domInsertion';\n\nimport type {\n  PageVisitCategory,\n  SupportedEventProductCategory,\n} from '@spiffy-ai/commerce-api-client';\nimport { ChatState } from 'src/types/custservice-types';\nimport { SuggestionBarLocationForMetrics } from 'src/types/suggestionBarV2-types';\nimport { TestProps } from 'src/types/test-types';\nimport { OrgConfigFeatureGate } from 'src/application/models/api/orgConfigResults';\n\ntype ShowFloatingButtonOptions =\n  | 'always'\n  | 'after-interaction-on-mobile-always-desktop'\n  | 'after-interaction-anywhere'\n  | 'never';\n\ntype FloatingEntryPointConfig = {\n  position: 'bottom-left' | 'middle-left' | 'middle-right' | 'bottom-right';\n  expansionText?: {\n    pdp: string;\n    plp: string;\n  };\n  minimizedColor: string;\n  expandedColor: string;\n  textColor?: string;\n  showOption: ShowFloatingButtonOptions;\n  iconSVGSrc?: string;\n  iconSize?: number;\n  iconStrokeColor?: string;\n  iconFillColor?: string;\n  height?: number;\n  fontSize?: number;\n};\n\ntype WelcomeSectionVariant = 'standard' | 'outlined';\n\ntype WelcomeSectionColorVariant = 'standard' | 'accent' | 'brand' | 'light';\n\ntype WelcomeSectionConfig = {\n  variant: WelcomeSectionVariant;\n  colorVariant?: WelcomeSectionColorVariant;\n  title?: string;\n  subtitle?: string;\n  // icon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;\n  /* Serializable icon name that maps to a React component. Preferred over icon for database storage. */\n  iconName?: string;\n  imageSrc?: string;\n};\n\ntype ChatPreviewConfig = {\n  variant: 'flat' | 'filled' | 'outlined';\n  largeProductComparison?: boolean;\n  filledBackgroundColor: string;\n  iconFillColor: string;\n  buttonTextColor?: string;\n  buttonTextSecondaryColor?: string;\n  buttonTextHoverColor?: string;\n  buttonBackgroundColor: string;\n  buttonBackgroundHoverColor: string;\n  buttonBorderColor?: string;\n  buttonBorderHoverColor?: string;\n  copies: { pdp: string[]; plp: string[] };\n  staticSuggestionCopies?: { pdp: string[]; plp: string[] };\n  staticPLPImages?: string[];\n  footerConfig?: ChatPreviewFooterConfig;\n  headerConfig?: ChatPreviewHeaderConfig;\n  topMargin?: number;\n};\n\ntype ChatPreviewHeaderConfig = {\n  title?: string;\n  imageSrc?: string;\n  imageHeight?: number;\n  sparklesColor?: string; // used by: spanx, uniqueVintage, dreamlandBaby\n  fontSize?: string;\n  iconWidth?: string;\n  iconHeight?: string;\n};\n\ninterface ChatPreviewFooterConfig {\n  hasFade?: boolean; // used by: spanx, uniqueVintage\n  suggestionButtonVariant?: 'dark' | 'light' | 'outlined';\n  suggestionsBackground?: string; // used by: carbahn\n  replyButtonIcon?: 'send' | 'magnifyingGlass' | 'thinMagnifyingGlass' | 'searchIcon';\n  replyButtonText?: string;\n  replyInputHasShadow?: boolean; // used by: spanx\n  replyInputHasBorder?: boolean; // used by: spanx\n  backgroundColor?: string; // used by spanx, tushbaby, will need custom CSS when switching over\n}\n\ntype ProductReviewStyleVariant = 'standard' | 'bordered';\n\ntype ProductReviewColorVariant = 'neutral' | 'brand' | 'premium';\n\ninterface ProductReviewConfig {\n  styleVariant: ProductReviewStyleVariant;\n  colorVariant: ProductReviewColorVariant;\n  verifiedBuyerTitle: string;\n  incentivizedReviewFlag?: boolean;\n}\n\ntype PageCardVariant = 'filled' | 'outlined' | 'minimal';\n\ntype PageCardHoverVariant = 'none' | 'shadow' | 'lift';\n\ntype PageCardIconVariant = 'primary' | 'accent' | 'background' | 'none';\n\ntype PageCardConfig = {\n  variant: PageCardVariant;\n  hoverVariant: PageCardHoverVariant;\n  iconVariant: PageCardIconVariant;\n};\n\ntype ProductCardVariant = 'filled' | 'bordered' | 'minimal' | 'transparentBordered';\n\ntype ProductCardHoverVariant = 'backgroundDark' | 'none';\n\ntype ProductCardLayoutVariant = 'normal' | 'tall' | 'square';\n\ninterface ProductCardConfig {\n  variant: ProductCardVariant;\n  hoverVariant: ProductCardHoverVariant;\n  layoutVariant: ProductCardLayoutVariant;\n  pricePrefix?: string;\n}\n\ntype CSSwitchConfig = {\n  variant: 'attached' | 'detached';\n  backgroundColor: string;\n  borderColor: string;\n  selectedTextColor: string;\n  selectedBackgroundColor?: string;\n  unselectedTextColor: string;\n  unselectedBackgroundColor?: string;\n  supportTitle?: string;\n  spiffyTitle?: string;\n  spiffyTitleHasLogo?: boolean;\n};\n\ntype ChatHeaderConfig = {\n  collapsedColor: string;\n  expandedColor: string;\n  chevronColor: string;\n  imageSrc?: string;\n  icon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;\n  closeIcon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;\n  borderBottom?: string;\n  headerBarHeightPartialView: number;\n  headerBarHeightFullView: number;\n  customerSupportSwitchConfig?: CSSwitchConfig;\n};\n\ntype SimpleCustomerServiceIntegration = {\n  integrationMode: CustomerServiceIntegrationMode;\n  provider: CustomerServiceType;\n  useUnifiedButton?: boolean;\n  maxfileUploadSize?: number;\n};\n\ntype FullCustomerServiceIntegration = {\n  integrationMode: CustomerServiceIntegrationMode;\n  provider: CustomerServiceType;\n  useUnifiedButton?: boolean;\n  chatEnabledDuringBusinessHours?: boolean;\n  showNameInput?: boolean;\n  formAiName?: string;\n  welcomeTitle: string;\n  welcomeDescription: string;\n  showWelcomeOnForm?: boolean;\n  contactSubjectOptions?: string[];\n  getCustomWaitingMessage?: (name?: string) => string;\n  withinBusinessHoursMessage?: string;\n  withinBusinessHoursWaitingMessage?: string;\n  outsideBusinessHoursMessage?: string;\n  outsideBusinessHoursWaitingMessage?: string;\n  withinBusinessHoursFormMessage?: string;\n  outsideBusinessHoursFormMessage?: string;\n  suggestedAIQuestions?: string[];\n  businessHoursPolling?: number;\n  maxfileUploadSize?: number;\n\n  /**\n   * @deprecated This is handled by the BE.\n   */\n  businessHoursStartUTC?: string;\n  /**\n   * @deprecated This is handled by the BE.\n   */\n  businessHoursEndUTC?: string;\n  /**\n   * @deprecated This is handled by the BE.\n   */\n  businessHoursTimezone?: string;\n\n  showAISuggestionsWithinBusinessHours?: boolean;\n  waitingMessagePosition?: 'BEFORE_MESSAGES' | 'AFTER_MESSAGES';\n  legalMessage?: string;\n  withinBusinessHoursInitialState?: ChatState;\n  outsideBusinessHoursInitialState?: ChatState;\n  withinBusinessHoursButtontext?: string;\n  outsideBusinessHoursButtontext?: string;\n  reopenChatMessage: string;\n};\n\ntype CustomerServiceIntegration = SimpleCustomerServiceIntegration | FullCustomerServiceIntegration;\n\ntype ConversationalSeach = {\n  enabled?: boolean;\n  replyInput?: ReplyInputConfig;\n  suggestions?: string[];\n  entrypointBgColor?: string;\n  entrypointTextColor?: string;\n  entrypointBtnColor?: string;\n  entrypointBtnTextColor?: string;\n  entrypointBtnBorderColor?: string;\n  entrypointContainer?: string;\n  entrypointTrigger?: string;\n  productGridContainer?: string;\n  generalSearchBtn?: string;\n  pageContent?: string;\n  searchContent?: string;\n  sortingTitle?: string;\n  selectionTitle?: string;\n  sortingFont?: string;\n  optionsFont?: string;\n  sortingButtonText?: string;\n};\n\ntype ChatMessageVariant = 'standard' | 'premium' | 'accent';\n\ninterface ChatMessageConfig {\n  assistantChatTitle: string;\n  variant: ChatMessageVariant;\n  productLink: {\n    variant: ProductLinkVariant;\n    hoverVariant: ProductLinkHoverVariant;\n    iconVariant: ProductLinkIconVariant;\n  };\n}\n\ninterface ReplyInputConfig {\n  // TODO consider making this a number\n  size?: 'md' | 'lg';\n  sendIcon: 'arrowUp' | 'send' | 'search';\n  placeholder?: string;\n}\n\ninterface PartialViewConfig {\n  // maximum height of the partial view as a percentage of the screen height\n  maxHeight: number;\n  borderRadius?: string;\n}\n\ntype ProductLinkIconVariant =\n  | 'accentPrimary'\n  | 'backgroundPrimary'\n  | 'backgroundPrimaryDark'\n  | 'borderLight'\n  | 'backgroundSaturated';\n\ntype ProductLinkVariant = 'textLink';\n\ntype ProductLinkHoverVariant = 'backgroundDark';\n\ntype SearchCardVariant =\n  | 'backgroundPrimary'\n  | 'backgroundSecondary'\n  | 'backgroundSecondaryDark'\n  | 'backgroundLight'\n  | 'backgroundSaturated';\n\ntype SuggestionButtonVariant =\n  | 'outlined'\n  | 'outlinedLight'\n  | 'primary'\n  | 'secondary'\n  | 'tertiary'\n  | 'dark'\n  | 'darkAccent'\n  | 'darkPrimary'\n  | 'secondaryDark'\n  | 'secondaryAccent'\n  | 'transparent'\n  | 'transparentDark'\n  | 'lightDark';\n\ninterface SuggestionButtonConfig {\n  variant?: SuggestionButtonVariant;\n  hoverVariant?: SuggestionButtonVariant;\n  answerVariant?: SuggestionButtonVariant;\n  borderRadius?: 'sm' | 'md' | 'lg';\n}\n\ntype NumRows = 'default' | 'alwaysOneRow' | 'alwaysTwoRows' | 'twoRowsOnMobile';\n\ninterface AlphabeticFilterSorting {\n  type: 'alphabetic';\n}\ninterface ProductCountFilterSorting {\n  type: 'productCount';\n}\ninterface CustomFilterSorting {\n  type: 'custom';\n  map: Record<string, number>;\n}\n\ntype FilterSorting = AlphabeticFilterSorting | ProductCountFilterSorting | CustomFilterSorting;\n\ninterface BaseFilterConfig {\n  filterId: string;\n  displayName: string;\n}\ninterface DynamicFilterConfig extends BaseFilterConfig {\n  type: 'dynamic';\n  attribute: string;\n  sorting: FilterSorting;\n}\n\ninterface PriceFilterConfig extends BaseFilterConfig {\n  type: 'price';\n  bucketSize: number;\n}\n\nexport type FilterAttribute = DynamicFilterConfig | PriceFilterConfig;\n\nexport type SearchZeroStateVariant = 'backgroundTertiary' | 'backgroundDark' | 'backgroundPrimary';\nexport type SearchZeroStateLayout = 'input' | 'icon';\n\nexport type SearchInputVariant = 'standard';\n\nexport type SearchIconVariant = 'thin' | 'bold';\n\nexport type SearchFilterSidebarVariant = 'darkButton' | 'lightButton';\n\nexport type ProductGridVariant = 'standard' | 'square';\n\ntype UserQueryButtonIcon =\n  | 'magnifyingGlass'\n  | 'send'\n  | 'magnifyingGlassThin'\n  | 'sendArrow'\n  | 'searchIcon';\n\ninterface UserQueryButtonConfig {\n  variant?: 'box' | 'underlineLight' | 'underlineDark';\n  placeholderText?: string;\n  icon: UserQueryButtonIcon;\n}\n\n// TODO: this should be included in the top-level widget config\ninterface TermsAndConditionsConfig {\n  copy: string;\n  link: string;\n  linkText: string;\n}\n\ninterface MerchantVariantSettings {\n  dynamicVariants: {\n    enabled: boolean; // This feature will enable dynamic variants for the merchant. Useful for SPA's\n    refreshInterval?: number; // The interval in milliseconds to check for changes in the URL\n  };\n}\n\ninterface FloatingChatConfig {\n  enableWatermark: boolean;\n  userQueryInputEnabled: boolean;\n  ignoreFirstModelResponse?: boolean;\n  neverShowSingleProductCards?: boolean;\n  termsAndConditionsConfig?: TermsAndConditionsConfig;\n\n  // Footer config\n  suggestionButtonConfig?: SuggestionButtonConfig;\n  replyInputConfig: ReplyInputConfig;\n}\n\ninterface SearchConfig {\n  enableGlobalSearch: boolean;\n  searchFilterConfig: FilterAttribute[];\n  searchOverlayHeading?: string;\n  redirectSearchResultsUrl?: string;\n  additiveDynamicFilters?: boolean;\n  recommendedProducts?: string[];\n  recommendedProductsHeading?: string;\n}\n\ntype OrgUIConfig = {\n  shortName: string;\n  id?: string;\n  floatingEntrypointConfig?: FloatingEntryPointConfig;\n  // Deprecated - remove with ChatPreview rewrite\n  chatPreviewConfig?: ChatPreviewConfig;\n\n  customerServiceIntegration: CustomerServiceIntegration;\n  // Deprecated - remove when Global Search is fully launched\n  conversationalSearch?: ConversationalSeach;\n\n  merchantOverrideCss?: string;\n\n  // Deprecated TODO: Remove this deprecated value when Groove CX has proper unified button support\n  // selectors for elements that should be hidden when the chat is open\n  // e.g. CS widgets with max z-index (\"div[id*='cs-container']\")\n  hiddenElementSelectors?: string[];\n\n  merchantVariantSettings?: MerchantVariantSettings;\n  // TODO: Migrate all floating chat config into this top-level key\n  //\n  floatingChatConfig: FloatingChatConfig;\n\n  // Contain all search config here\n  searchConfig: SearchConfig;\n  // TODO: Move these into FloatingChatConfig\n  // Chat Header related values\n  chatHeader: ChatHeaderConfig;\n  stickyAgentSwitchSuggestion?: boolean;\n  partialViewConfig: PartialViewConfig;\n  welcomeSectionConfig?: WelcomeSectionConfig;\n  // Different response values\n  productCardConfig?: ProductCardConfig;\n  productReviewConfig?: ProductReviewConfig;\n  pageCardConfig?: PageCardConfig;\n  chatMessageConfig: ChatMessageConfig;\n};\n\ntype InsertionPoint = {\n  selector: string;\n  // this is the index of the target element, 0 if missing\n  selectionIndex?: number;\n  insertionType: DOMInsertionType;\n};\n\ntype URLTest = 'shopify' | 'null';\n\ntype IdExtractor =\n  | 'shopify-product-id'\n  | 'shopify-collection-id'\n  | 'shopify-product-variant-id'\n  | 'url-resolver-product-id'\n  | 'url-resolver-plp-id'\n  | 'null';\n\n// This contains a map between PageVisitCategory and a list of URL's that are classified as the value\nenum CategoryExtractorType {\n  VisitCategoryMap = 'VisitCategoryMap',\n  VisitCategoryDefault = 'VisitCategoryDefault',\n}\n\ninterface BaseCategoryExtractor<T extends CategoryExtractorType> {\n  type: T;\n}\n\n// This map betweens a category and a list of url patterns\ninterface VisitCategoryMap extends BaseCategoryExtractor<CategoryExtractorType.VisitCategoryMap> {\n  map: {\n    [key in PageVisitCategory]?: string[];\n  };\n}\n\n// This will return a hard-coded default PageVisitCategory. It is intended to be used by fallback page types\ninterface VisitCategoryDefault extends BaseCategoryExtractor<CategoryExtractorType.VisitCategoryDefault> {\n  value: PageVisitCategory;\n}\n\ntype CategoryExtractor = VisitCategoryMap | VisitCategoryDefault;\n\ntype WrappingElement = {\n  className: string;\n  element: string;\n  insertionType: DOMInsertionType;\n};\n\nenum PageVariantTestType {\n  ShopifyPLP = 'ShopifyPLP',\n  ShopifyPDP = 'ShopifyPDP',\n  PageCategory = 'PageCategory',\n  CatalogCategory = 'CatalogCategory',\n  TopCatalogCategory = 'TopCatalogCategory',\n  HasReviews = 'HasReviews',\n  InCollection = 'InCollection',\n  HasMerchantTag = 'HasMerchantTag',\n  FeatureGate = 'FeatureGate',\n  PlpId = 'PlpId',\n  QueryParam = 'QueryParam',\n  ProductId = 'ProductId',\n  UserHasInteracted = 'UserHasInteracted',\n  UserHasNotInteracted = 'UserHasNotInteracted',\n  isLoading = 'isLoading',\n  isProductComparison = 'isProductComparison',\n  Fallback = 'Fallback',\n  UrlResolver = 'UrlResolver',\n  Null = 'null',\n}\n\ninterface BasePageVariantTest<T extends PageVariantTestType> {\n  testType: T;\n}\n\ninterface TopCatalogCategory extends BasePageVariantTest<PageVariantTestType.TopCatalogCategory> {\n  topCategory: string[];\n}\n\ninterface CatalogCategoryTest extends BasePageVariantTest<PageVariantTestType.CatalogCategory> {\n  category: SupportedEventProductCategory;\n}\n\ninterface HasReviewsTest extends BasePageVariantTest<PageVariantTestType.HasReviews> {\n  reviewMinimum?: number;\n}\n\n// This will return true if the product is in any of the listed collections\ninterface InCollectionTest extends BasePageVariantTest<PageVariantTestType.InCollection> {\n  collections: string[];\n}\n\n// This will return true if the product has any of the listed merchant tags\ninterface HasMerchantTagTest extends BasePageVariantTest<PageVariantTestType.HasMerchantTag> {\n  merchantTags: string[];\n}\n\ninterface ShopifyPLPURLTest extends BasePageVariantTest<PageVariantTestType.ShopifyPLP> {}\n\ninterface ShopifyPDPURLTest extends BasePageVariantTest<PageVariantTestType.ShopifyPDP> {}\n\ninterface PageCategoryTest extends BasePageVariantTest<PageVariantTestType.PageCategory> {\n  extractor: CategoryExtractor;\n}\n\ninterface FeatureGateTest extends BasePageVariantTest<PageVariantTestType.FeatureGate> {\n  featureGate: FeatureGates;\n}\n\ninterface ProductIdTest extends BasePageVariantTest<PageVariantTestType.ProductId> {\n  productIdExtractor: IdExtractor;\n  productIds: string[];\n}\n\ninterface PlpIdTest extends BasePageVariantTest<PageVariantTestType.PlpId> {\n  plpIdExtractor: IdExtractor;\n  plpIds: string[];\n}\n\ninterface QueryParamTest extends BasePageVariantTest<PageVariantTestType.QueryParam> {\n  queryParam: string;\n}\n\ninterface UserHasInteractedTest extends BasePageVariantTest<PageVariantTestType.UserHasInteracted> {}\n\ninterface UserHasNotInteractedTest extends BasePageVariantTest<PageVariantTestType.UserHasNotInteracted> {}\n\ninterface IsLoadingTest extends BasePageVariantTest<PageVariantTestType.isLoading> {}\n\ninterface IsProductComparison extends BasePageVariantTest<PageVariantTestType.isProductComparison> {}\n\ninterface PageFallbackTest extends BasePageVariantTest<PageVariantTestType.Fallback> {}\n\ninterface UrlResolverTest extends BasePageVariantTest<PageVariantTestType.UrlResolver> {}\n\nexport type PageVariantTest =\n  | PageCategoryTest\n  | ShopifyPLPURLTest\n  | ShopifyPDPURLTest\n  | CatalogCategoryTest\n  | TopCatalogCategory\n  | HasReviewsTest\n  | InCollectionTest\n  | HasMerchantTagTest\n  | FeatureGateTest\n  | ProductIdTest\n  | PlpIdTest\n  | QueryParamTest\n  | UserHasInteractedTest\n  | UserHasNotInteractedTest\n  | IsLoadingTest\n  | IsProductComparison\n  | PageFallbackTest\n  | UrlResolverTest;\n\n/**\n * Configuration for the social proof embedded widget\n *\n * @param headerTitle - The title text to display in the widget header\n * @param staticSuggestions - A list of strings to display as suggestions in the widget\n * @param suggestionButtonVariantDefault - The variant of the suggestion button to display in the widget footer\n * @param suggestionButtonVariantAccent - The variant of the suggestion button to display in the widget body\n * @param staticImageIndex - Index of the imageUrl to use from the product response\n */\ninterface SocialProofConfig {\n  customerQuery: string;\n  headerTitle: string;\n  staticPLPImagesLayout?: 'grid' | 'horizontal';\n  headerFontFamily?: string;\n  staticPLPImageNames?: string[];\n  staticImageIndex?: number;\n  suggestionButtonStrings: string[];\n  suggestionButtonVariantDefault: SuggestionButtonVariant;\n  suggestionButtonVariantAccent?: SuggestionButtonVariant;\n  suggestionButtonDataAttributes?: Record<string, string>;\n  userQueryButtonConfig?: UserQueryButtonConfig;\n  logoName?: string;\n}\n\n/**\n * Configuration for creating the mount point for a widget\n *\n * @param className - Optional class name to apply to the mount point. Tailwind classes are supported\n * and encouraged. Use this parameter to style the mounting container for the widget.\n */\nexport type WidgetMountingConfig = {\n  mountingConfigId: string;\n  containerId: string;\n  testId: string;\n  parentInsertionPoint?: InsertionPoint;\n  insertionPoint: InsertionPoint;\n  gridInsertionType?: GridInsertionType;\n  wrappingElement?: WrappingElement;\n  divCheckSelector?: string;\n  suppressionSelector?: string;\n  style?: Partial<CSSStyleDeclaration>;\n  className?: string;\n  dataAttributes?: Record<string, string>;\n};\n\ntype StaticWidgetMounting = {\n  mountingConfigId: string;\n  widgetConfigId: string;\n};\ntype DynamicWidgetMounting = {\n  mountingConfigId: string;\n  mountingPointWidgets: WidgetDisplayTests[];\n};\n\ntype WidgetDisplayTests = {\n  tests: PageVariantTest[];\n  widgetConfigId: string;\n};\n\ntype WidgetMounting = StaticWidgetMounting | DynamicWidgetMounting;\n\nenum WidgetType {\n  ChatPreview = 'ChatPreview',\n  SocialProofV2 = 'SocialProofV2',\n  ChatPreviewV2 = 'ChatPreviewV2',\n  ChatPreviewIsLoading = 'ChatPreviewIsLoading',\n  ChatPreviewPostInteraction = 'ChatPreviewPostInteraction',\n  ChatPreviewProductComparison = 'ChatPreviewProductComparison',\n  SuggestionBar = 'SuggestionBar',\n  SuggestionBarV2 = 'SuggestionBarV2',\n  ImagePromptCard = 'ImagePromptCard',\n  ImageBanner = 'ImageBanner',\n  SingleImagePrompt = 'SingleImagePrompt',\n  SearchPrompt = 'SearchPrompt',\n  SearchZeroStateEntryPoint = 'SearchZeroStateEntryPoint',\n  SearchResultsEntryPoint = 'SearchResultsEntryPoint',\n  SearchOverlayHost = 'SearchOverlayHost',\n  NoOp = 'NoOp',\n}\n\nexport enum WidgetTypeV3 {\n  SuggestionBarV3 = 'SuggestionBarV3',\n  ChatPreviewV3 = 'ChatPreviewV3',\n  SocialProofV3 = 'SocialProofV3',\n  ImagePromptCardV3 = 'ImagePromptCardV3',\n  ImageBannerV3 = 'ImageBannerV3',\n  SingleImagePromptV3 = 'SingleImagePromptV3',\n}\n\ntype WidgetConfig =\n  | ChatPreviewWidgetConfig\n  | SocialProofV2WidgetConfig\n  | ChatPreviewV2WidgetConfig\n  | ChatPreviewPostInteractionWidgetConfig\n  | ChatPreviewIsLoadingWidgetConfig\n  | ChatPreviewProductComparisonWidgetConfig\n  | SuggestionBarWidgetV2Config\n  | ImagePromptWidgetConfig\n  | ImageBannerWidgetConfig\n  | SingleImagePromptWidgetConfig\n  | SearchPromptWidgetConfig\n  | SearchEntryPointWidgetConfig\n  | SearchResultsEntryPointWidgetConfig\n  | SearchOverlayHostWidgetConfig\n  | NoOpWidgetConfig;\n\ninterface BaseWidgetConfig<T extends WidgetType> {\n  widgetConfigId: string;\n  type: T;\n  contentId?: string;\n}\n\ninterface ImageBannerWidgetConfig extends BaseWidgetConfig<WidgetType.ImageBanner> {\n  imageSrc: string;\n  title: string;\n  subtitle: string;\n  assistantMessage: string;\n}\n\ninterface ChatPreviewWidgetConfig extends BaseWidgetConfig<WidgetType.ChatPreview> {\n  variant: 'filled' | 'flat' | 'outlined';\n  addSeparators?: boolean;\n  socialProofConfig?: SocialProofConfig;\n  footerConfig?: ChatPreviewFooterConfig;\n}\n\ninterface ChatPreviewHeaderV2Config {\n  title?: string; // Default: 'Shopping Assistant'\n  imageSrc?: string;\n  imageHeight?: number;\n}\n\ntype SingleImageConfig = {\n  layout: 'single';\n  imageIndex: number;\n};\ntype MultiImageConfig = {\n  layout: 'grid' | 'horizontal';\n  imageNames: string[];\n};\ntype SocialProofImageConfig = SingleImageConfig | MultiImageConfig;\n\ntype ChatPreviewSuggestionButtonConfig = {\n  buttonStrings: string[];\n  accentButtonVariants?: {\n    button: SuggestionButtonVariant;\n    hover: SuggestionButtonVariant;\n  };\n  buttonVariants: {\n    button: SuggestionButtonVariant;\n    hover: SuggestionButtonVariant;\n  };\n  numRows?: NumRows;\n};\n\ntype ChatPreviewAnimatedTextConfig = {\n  leadingText: string;\n  animatedStrings: string[];\n};\n\ntype ChatPreviewVariant =\n  | { variant: 'flat' }\n  | { variant: 'filled'; backgroundFillColor: string }\n  | { variant: 'outlined' };\n\n// Base interface for common chat preview properties\ninterface BaseChatPreviewConfig {\n  headerConfig: ChatPreviewHeaderV2Config;\n  suggestionButtonsConfig: ChatPreviewSuggestionButtonConfig;\n  userQueryButtonConfig: UserQueryButtonConfig;\n  chatPreviewVariant: ChatPreviewVariant;\n  addSeparators?: boolean;\n}\n\n// Specific chat preview widget configurations\ninterface ChatPreviewPostInteractionWidgetConfig\n  extends BaseWidgetConfig<WidgetType.ChatPreviewPostInteraction>, BaseChatPreviewConfig {\n  chatPreviewVariant: ChatPreviewVariant;\n  addSeparators?: boolean;\n}\n\ninterface ChatPreviewIsLoadingWidgetConfig\n  extends BaseWidgetConfig<WidgetType.ChatPreviewIsLoading>, BaseChatPreviewConfig {}\n\ninterface ChatPreviewProductComparisonWidgetConfig\n  extends BaseWidgetConfig<WidgetType.ChatPreviewProductComparison>, BaseChatPreviewConfig {\n  useLargeProductComparison?: boolean;\n}\n\ninterface ChatPreviewV2WidgetConfig\n  extends BaseWidgetConfig<WidgetType.ChatPreviewV2>, BaseChatPreviewConfig {\n  animatedTextConfig: ChatPreviewAnimatedTextConfig;\n}\n\ninterface SocialProofV2WidgetConfig\n  extends BaseWidgetConfig<WidgetType.SocialProofV2>, BaseChatPreviewConfig {\n  customerQuery?: string; // Default: 'asked which products are the best'\n  imageConfig: SocialProofImageConfig;\n}\n\ninterface SuggestionBarWidgetV2Config extends BaseWidgetConfig<WidgetType.SuggestionBarV2> {\n  metricDisplayLocation: ChatElementDisplayLocation;\n  location: SuggestionBarLocationForMetrics;\n  variant: SuggestionButtonVariant;\n  hoverVariant: SuggestionButtonVariant;\n  buttonTexts: {\n    default: string[];\n    productSpecific?: { [productId: string]: string[] };\n  };\n  boldFirstButton?: boolean;\n  twoRowsOnMobile?: boolean;\n  animationSpeed?: 'standard' | 'slow' | 'none';\n  buttonBorderRadius?: 'sm' | 'md' | 'lg';\n}\n\ninterface ImagePromptWidgetConfig extends BaseWidgetConfig<WidgetType.ImagePromptCard> {\n  url: string;\n  lightText?: boolean;\n  title: string;\n  subtitle: string[];\n  staticSuggestionCopies: string[];\n  userQueryButtonConfig: UserQueryButtonConfig;\n  fallbackBackgroundColor?: string;\n}\n\ninterface SingleImagePromptWidgetConfig extends BaseWidgetConfig<WidgetType.SingleImagePrompt> {\n  title: string;\n  staticSuggestionCopies: string[];\n  userQueryButtonConfig: UserQueryButtonConfig;\n}\n\ninterface SearchEntryPointWidgetConfig extends BaseWidgetConfig<WidgetType.SearchZeroStateEntryPoint> {\n  searchZeroStateVariant: SearchZeroStateVariant;\n  searchInputVariant: SearchInputVariant;\n  searchIconVariant?: SearchIconVariant;\n  searchIconSize?: number;\n  suggestionButtonConfig: SuggestionButtonConfig;\n  layout: SearchZeroStateLayout;\n  searchBoxPlaceholder: string;\n  animationSpeed?: 'standard' | 'slow' | 'none';\n  compactLabel?: string;\n  initialSuggestions?: string[];\n  usingPortal?: boolean;\n  includeSubtitle?: boolean;\n}\n\ninterface NoOpWidgetConfig extends BaseWidgetConfig<WidgetType.NoOp> {}\ninterface SearchOverlayHostWidgetConfig extends BaseWidgetConfig<WidgetType.SearchOverlayHost> {}\n\ninterface SearchResultsEntryPointWidgetConfig extends BaseWidgetConfig<WidgetType.SearchResultsEntryPoint> {\n  searchInputVariant: SearchInputVariant;\n  searchFilterSidebarVariant: SearchFilterSidebarVariant;\n  productGridVariant: ProductGridVariant;\n  searchBoxPlaceholder: string;\n  noResultsFoundText?: string;\n}\n\nexport interface WidgetHeaderProps extends TestProps {\n  title?: string;\n  logo?: string;\n  logoHeight?: number;\n  orgShortName: string;\n  variant?: SearchPromptVariant;\n}\n\nexport interface UserQueryOptions {\n  footerVariant?: 'standard';\n  replyButtonText?: string;\n  replyButtonIcon?: 'magnifyingGlass' | 'send' | 'thinMagnifyingGlass' | 'ai-search';\n}\n\ntype SearchPromptVariant = 'primary';\ninterface SearchPromptWidgetConfig extends BaseWidgetConfig<WidgetType.SearchPrompt> {\n  variant: SearchPromptVariant;\n  title: string;\n  headerConfig: WidgetHeaderProps;\n  suggestionButtons: {\n    variant: SuggestionButtonVariant;\n    hoverVariant: SuggestionButtonVariant;\n    buttonTexts: string[];\n  };\n  footerConfig?: UserQueryOptions;\n}\n\ntype PageVariantBase = {\n  // Unique identifier for each entry within the pageVariants.\n  // Useful to differentiate which variant is loaded when there are multiples of a single type.\n  variantId: string;\n  widgetMounting: WidgetMounting[];\n  variantTests: PageVariantTest[];\n};\n\ntype PLPPageVariant = PageVariantBase & {\n  variantType: 'plp';\n  plpIdExtractor: IdExtractor;\n};\n\ntype PDPPageVariant = PageVariantBase & {\n  variantType: 'pdp';\n  parentProductIdExtractor?: IdExtractor;\n  productIdExtractor: IdExtractor;\n};\n\ntype VisitPageVariant = PageVariantBase & {\n  variantType: 'page_visit';\n};\n\ntype OtherPageVariant = PageVariantBase & {\n  variantType: 'other';\n};\n\ntype HomePageVariant = PageVariantBase & {\n  variantType: 'homepage';\n};\n\ntype SearchPageVariant = PageVariantBase & {\n  variantType: 'search';\n};\n\nexport type PageVariantConfig =\n  | PLPPageVariant\n  | PDPPageVariant\n  | VisitPageVariant\n  | OtherPageVariant\n  | HomePageVariant\n  | SearchPageVariant;\n\nexport type OrgPageConfig = {\n  // pageVariants is a list of page variants that we support.\n  pageVariants: PageVariantConfig[];\n  // widgetConfigs is a named set of widget configs\n  widgetConfigs: Record<string, WidgetConfig>;\n  mountingConfigs: Record<string, WidgetMountingConfig>;\n};\n\nexport type OrgConfig = OrgUIConfig;\n\nexport { CategoryExtractorType, ColorNames, colorVar, PageVariantTestType, WidgetType };\n\nexport interface EnviveConfig {\n  amplitudeApiKey?: string;\n  dataResidency?: string;\n  env?: string;\n  baseUrl?: string;\n  reactAppName?: string;\n  cdnUrl?: string;\n  contextSource?: string;\n  orgLevelApiKey?: string;\n  orgShortName?: string;\n  identifyingPrefix?: string;\n  featureOverrides?: Record<string, boolean>;\n  variantUrlOverride?: string;\n  variantInfoOverride?: any;\n  show?: boolean;\n  publicKey?: string;\n  featureGates?: OrgConfigFeatureGate[];\n}\n\nexport type {\n  CategoryExtractor,\n  ChatMessageVariant,\n  ChatMessageConfig,\n  ChatPreviewConfig,\n  ChatPreviewIsLoadingWidgetConfig,\n  ChatPreviewPostInteractionWidgetConfig,\n  ChatPreviewProductComparisonWidgetConfig,\n  ChatPreviewSuggestionButtonConfig,\n  SocialProofV2WidgetConfig,\n  ChatPreviewHeaderV2Config,\n  ChatPreviewV2WidgetConfig,\n  ChatPreviewFooterConfig,\n  ChatPreviewHeaderConfig,\n  ChatPreviewWidgetConfig,\n  ChatPreviewVariant,\n  ColorMapping,\n  CustomerServiceIntegration,\n  FloatingEntryPointConfig,\n  FullCustomerServiceIntegration,\n  IdExtractor,\n  ImageBannerWidgetConfig,\n  ImagePromptWidgetConfig,\n  InsertionPoint,\n  MultiImageConfig,\n  OrgUIConfig,\n  PageCardConfig,\n  PageCardVariant,\n  PageCardHoverVariant,\n  PageCardIconVariant,\n  ProductCardConfig,\n  ProductCardVariant,\n  ProductCardLayoutVariant,\n  ProductCardHoverVariant,\n  ProductLinkHoverVariant,\n  ProductLinkIconVariant,\n  ProductLinkVariant,\n  ProductReviewConfig,\n  ProductReviewStyleVariant,\n  ProductReviewColorVariant,\n  SearchPromptVariant,\n  SearchPromptWidgetConfig,\n  SearchResultsEntryPointWidgetConfig,\n  ShowFloatingButtonOptions,\n  SingleImagePromptWidgetConfig,\n  SearchEntryPointWidgetConfig,\n  SearchOverlayHostWidgetConfig,\n  SocialProofConfig,\n  SuggestionBarWidgetV2Config,\n  SuggestionButtonConfig,\n  SuggestionButtonVariant,\n  URLTest,\n  UserQueryButtonConfig,\n  UserQueryButtonIcon,\n  WelcomeSectionConfig,\n  WelcomeSectionVariant,\n  WelcomeSectionColorVariant,\n  WidgetConfig,\n  WrappingElement,\n  SearchCardVariant,\n  WidgetDisplayTests,\n  NoOpWidgetConfig,\n  WidgetMounting,\n  StaticWidgetMounting,\n  DynamicWidgetMounting,\n  PDPPageVariant,\n  PLPPageVariant,\n  VisitPageVariant,\n  OtherPageVariant,\n  HomePageVariant,\n  SearchPageVariant,\n  NumRows,\n};\n"],"mappings":";;;AA+bA,IAAK,0EAAL;AACE;AACA;;EAFG;AA6BL,IAAK,sEAAL;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;EAnBG;AAuKL,IAAK,oDAAL;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;EAhBG;AAmBL,IAAY,wDAAL;AACL;AACA;AACA;AACA;AACA;AACA"}