@envive-ai/react-hooks 0.1.2 → 0.1.4

package/dist/orgConfigResults-BL0XBA6x.d.cts

@@ -0,0 +1,881 @@
+import { CustomerServiceIntegrationMode, CustomerServiceType } from "./types-CD4LFta-.cjs";
+import { ChatState, SuggestionBarLocationForMetrics, TestProps } from "./test-types-CuOq25VT.cjs";
+import { OrganizationStatusEnum, PageVisitCategory, SupportedEventProductCategory } from "@spiffy-ai/commerce-api-client";
+
+//#region src/application/models/api/orgAnalyticsConfig.d.ts
+interface OrgAnalyticsConfig {
+  amplitude?: OrgAnalyticsAmplitudeConfig;
+  customerService?: OrgAnalyticsCustomerServiceConfig;
+  googleAnalytics?: OrgAnalyticsGoogleAnalyticsConfig;
+}
+interface OrgAnalyticsAmplitudeConfig {
+  sessionReplayEnabled: boolean;
+  sessionReplaySampleRate: number;
+  trackingEnabled: boolean;
+}
+interface OrgAnalyticsCustomerServiceConfig {
+  provider: string;
+}
+interface OrgAnalyticsGoogleAnalyticsConfig {
+  measurementId?: string;
+}
+//#endregion
+//#region src/application/models/api/organizationConfig.d.ts
+interface OrganizationConfig$1 {
+  createdAt: string;
+  namespace: string;
+  isLatest: boolean;
+  version: string;
+  updatedAt: string;
+  config: OrgAnalyticsConfig;
+  organizationId?: string;
+  id?: string;
+}
+//#endregion
+//#region src/application/models/colorsConfig.d.ts
+declare enum ColorNames {
+  TextPrimary = "text-primary",
+  TextSecondary = "text-secondary",
+  TextAccent = "text-accent",
+  TextLink = "text-link",
+  TextLight = "text-light",
+  BackgroundPrimary = "background-primary",
+  BackgroundSecondary = "background-secondary",
+  BackgroundSecondaryDark = "background-secondary-dark",
+  BackgroundTertiary = "background-tertiary",
+  BackgroundDark = "background-dark",
+  BackgroundLight = "background-light",
+  BackgroundSaturated = "background-saturated",
+  BorderLight = "border-light",
+  BorderMedium = "border-medium",
+  BorderDark = "border-dark",
+  BorderOutline = "border-outline",
+  AccentPrimary = "accent-primary",
+  AccentSecondary = "accent-secondary",
+}
+type ColorMapping = { [key in ColorNames]: string };
+declare const colorVar: (color: ColorNames) => string;
+//#endregion
+//#region src/application/models/chatElementDisplayLocation.d.ts
+declare enum ChatElementDisplayLocation {
+  IN_CHAT = "in_chat",
+  CHAT_PREVIEW = "chat_preview",
+  FLOATING_BUTTON = "floating_button",
+  HELP_ME_CHOOSE = "help_me_choose",
+  PLP_IMAGE_BANNER = "plp_image_banner",
+  TOP_REVIEWS_SNIPPET = "top_reviews_snippet",
+  BOTTOM_REVIEWS_SNIPPET = "bottom_reviews_snippet",
+  BLOCK_BACK_BUTTON = "block_back_button",
+  SWITCH_TO_AGENT = "switch_to_agent",
+  CONVERSATIONAL_SEARCH = "conversational_search",
+  GLOBAL_SEARCH_ENTRYPOINT = "global_search_entrypoint",
+  SEARCH_NAV_ENTRYPOINT = "search_nav_entrypoint",
+  SEARCH_PROMPT = "search_prompt",
+  SEARCH_PROMPT_BUTTON = "search_prompt_button",
+  PRODUCT_GRID = "product_grid",
+  UNSPECIFIED = "unspecified",
+  FILTER_MODAL = "filter_modal",
+  PROMPT_CARD = "prompt_card",
+  WINDOW_API_CALL = "window_api_call",
+}
+//#endregion
+//#region src/application/models/featureGates.d.ts
+declare enum FeatureGates {
+  IsClientSessionEnabled = "is_client_session_enabled",
+  IsNewFeatureEnabled = "is_new_feature_enabled",
+  IsFineTunedModel8b = "is_fine_tuned_model_8b",
+  IsIntegratedCXEnabled = "is_integrated_cx_enabled",
+  IsNonShapewearEnabled = "is_non_shapewear_enabled",
+  IsImageBannerEnabled = "is_image_banner_enabled",
+  IsOrderLookupEnabled = "is_order_lookup_enabled",
+  IsSummarizeReviewsEnabled = "is_summarize_reviews_enabled",
+  IsGlobalSearchEnabled = "is_global_search_enabled",
+  IsImagePromptEnabled = "is_image_prompt_enabled",
+  IsWatermarkEnabled = "is_watermark_enabled",
+  IsInferenceRegion0 = "is_inference_region_0",
+  IsGraphQLUIConfigsEnabled = "is_graphql_ui_configs_enabled",
+  IsGraphQLPageConfigsEnabled = "is_graphql_page_configs_enabled",
+  IsGraphQLComponentConfigsEnabled = "is_graphql_component_configs_enabled",
+  IsChatVariantEnabled = "is_chat_variant_enabled",
+  IsChatVariantAEnabled = "is_chat_variant_a_enabled",
+  IsChatVariantBEnabled = "is_chat_variant_b_enabled",
+  IsUserQueryAlwaysEnabled = "is_user_query_always_enabled",
+}
+//#endregion
+//#region src/application/service/domMutations/domInsertionService.d.ts
+declare enum DOMInsertionType {
+  AFTER = "after",
+  BEFORE = "before",
+  ADJACENT_AFTER_BEGIN = "adjacent-after-begin",
+  ADJACENT_BEFORE_BEGIN = "adjacent-before-begin",
+  ADJACENT_AFTER_END = "adjacent-after-end",
+  ADJACENT_BEFORE_END = "adjacent-before-end",
+  APPEND_CHILD = "append-child",
+  NONE = "none",
+}
+declare const DOMInsertionTypeToInsertPosition: (type: DOMInsertionType) => InsertPosition;
+declare class DOMInsertionService {
+  static insert(targetElement: Element, nodeToInsert: HTMLElement, insertionType: DOMInsertionType): void;
+  /**
+   * Get the insertion point for the widget.
+   * @param selector - The selector to find the insertion point.
+   * @param selectionIndex - For multiple matches, pick the nth element. Can be negative to insert from the end (-1 is the last element). (optional, default first)
+   * @returns The insertion point element or null if not found.
+   */
+  static getInsertionPoint(selector: string, selectionIndex?: number): Element | null;
+}
+//#endregion
+//#region src/application/service/domMutations/GridInsertionService.d.ts
+declare enum GridInsertionType {
+  FIXED_1 = "fixed-1",
+  FIXED_2 = "fixed-2",
+  FIXED_3 = "fixed-3",
+  FIXED_4 = "fixed-4",
+  FIXED_5 = "fixed-5",
+  FIXED_6 = "fixed-6",
+  FIXED_7 = "fixed-7",
+  FIXED_8 = "fixed-8",
+  FIXED_9 = "fixed-9",
+  FIXED_12 = "fixed-12",
+  FIXED_13 = "fixed-13",
+  ROW_1 = "row-1",
+  ROW_2 = "row-2",
+  ROW_3 = "row-3",
+  ROW_4 = "row-4",
+}
+declare class GridInsertionService {
+  static insert(gridInsertionType: GridInsertionType, targetElement: Element, nodeToInsert: HTMLElement, insertionType: DOMInsertionType): void;
+  /**
+   * Inserts a node into a grid row at the specified index starting from index 1. If the index
+   * is higher than the total number of rows, the node will be inserted at the end of the grid.
+   * This function does not make any assumptions about the column span of the inserted node - that
+   * should be handled by the orgConfig instead.
+   *
+   * @param targetElement - The target element to insert the node into.
+   * @param nodeToInsert - The node to insert into the grid.
+   * @param rowIndex - The index of the row to insert the node into.
+   */
+  static rowInsert(targetElement: Element, nodeToInsert: HTMLElement, rowIndex: number): void;
+  static fixedInsert(targetElement: Element, insertionGridIndex: number, nodeToInsert: HTMLElement, insertionType: DOMInsertionType): void;
+}
+//#endregion
+//#region src/contexts/types.d.ts
+type ShowFloatingButtonOptions = "always" | "after-interaction-on-mobile-always-desktop" | "after-interaction-anywhere" | "never";
+type FloatingEntryPointConfig = {
+  position: "bottom-left" | "middle-left" | "middle-right" | "bottom-right";
+  expansionText?: {
+    pdp: string;
+    plp: string;
+  };
+  minimizedColor: string;
+  expandedColor: string;
+  textColor?: string;
+  showOption: ShowFloatingButtonOptions;
+  iconSVGSrc?: string;
+  iconSize?: number;
+  iconStrokeColor?: string;
+  iconFillColor?: string;
+  height?: number;
+  fontSize?: number;
+};
+type WelcomeSectionVariant = "standard" | "outlined";
+type WelcomeSectionColorVariant = "standard" | "accent" | "brand" | "light";
+type WelcomeSectionConfig = {
+  variant: WelcomeSectionVariant;
+  colorVariant?: WelcomeSectionColorVariant;
+  title?: string;
+  subtitle?: string;
+  iconName?: string;
+  imageSrc?: string;
+};
+type ChatPreviewConfig = {
+  variant: "flat" | "filled" | "outlined";
+  largeProductComparison?: boolean;
+  filledBackgroundColor: string;
+  iconFillColor: string;
+  buttonTextColor?: string;
+  buttonTextSecondaryColor?: string;
+  buttonTextHoverColor?: string;
+  buttonBackgroundColor: string;
+  buttonBackgroundHoverColor: string;
+  buttonBorderColor?: string;
+  buttonBorderHoverColor?: string;
+  copies: {
+    pdp: string[];
+    plp: string[];
+  };
+  staticSuggestionCopies?: {
+    pdp: string[];
+    plp: string[];
+  };
+  staticPLPImages?: string[];
+  footerConfig?: ChatPreviewFooterConfig;
+  headerConfig?: ChatPreviewHeaderConfig;
+  topMargin?: number;
+};
+type ChatPreviewHeaderConfig = {
+  title?: string;
+  imageSrc?: string;
+  imageHeight?: number;
+  sparklesColor?: string;
+  fontSize?: string;
+  iconWidth?: string;
+  iconHeight?: string;
+};
+interface ChatPreviewFooterConfig {
+  hasFade?: boolean;
+  suggestionButtonVariant?: "dark" | "light" | "outlined";
+  suggestionsBackground?: string;
+  replyButtonIcon?: "send" | "magnifyingGlass" | "thinMagnifyingGlass" | "searchIcon";
+  replyButtonText?: string;
+  replyInputHasShadow?: boolean;
+  replyInputHasBorder?: boolean;
+  backgroundColor?: string;
+}
+type ProductReviewStyleVariant = "standard" | "bordered";
+type ProductReviewColorVariant = "neutral" | "brand" | "premium";
+interface ProductReviewConfig {
+  styleVariant: ProductReviewStyleVariant;
+  colorVariant: ProductReviewColorVariant;
+  verifiedBuyerTitle: string;
+  incentivizedReviewFlag?: boolean;
+}
+type PageCardVariant = "filled" | "outlined" | "minimal";
+type PageCardHoverVariant = "none" | "shadow" | "lift";
+type PageCardIconVariant = "primary" | "accent" | "background" | "none";
+type PageCardConfig = {
+  variant: PageCardVariant;
+  hoverVariant: PageCardHoverVariant;
+  iconVariant: PageCardIconVariant;
+};
+type ProductCardVariant = "filled" | "bordered" | "minimal" | "transparentBordered";
+type ProductCardHoverVariant = "backgroundDark" | "none";
+type ProductCardLayoutVariant = "normal" | "tall" | "square";
+interface ProductCardConfig {
+  variant: ProductCardVariant;
+  hoverVariant: ProductCardHoverVariant;
+  layoutVariant: ProductCardLayoutVariant;
+  pricePrefix?: string;
+}
+type CSSwitchConfig = {
+  variant: "attached" | "detached";
+  backgroundColor: string;
+  borderColor: string;
+  selectedTextColor: string;
+  selectedBackgroundColor?: string;
+  unselectedTextColor: string;
+  unselectedBackgroundColor?: string;
+  supportTitle?: string;
+  spiffyTitle?: string;
+  spiffyTitleHasLogo?: boolean;
+};
+type ChatHeaderConfig = {
+  collapsedColor: string;
+  expandedColor: string;
+  chevronColor: string;
+  imageSrc?: string;
+  icon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+  closeIcon?: React.FunctionComponent<React.SVGProps<SVGSVGElement>>;
+  borderBottom?: string;
+  headerBarHeightPartialView: number;
+  headerBarHeightFullView: number;
+  customerSupportSwitchConfig?: CSSwitchConfig;
+};
+type SimpleCustomerServiceIntegration = {
+  integrationMode: CustomerServiceIntegrationMode;
+  provider: CustomerServiceType;
+  useUnifiedButton?: boolean;
+};
+type FullCustomerServiceIntegration = {
+  integrationMode: CustomerServiceIntegrationMode;
+  provider: CustomerServiceType;
+  useUnifiedButton?: boolean;
+  chatEnabledDuringBusinessHours?: boolean;
+  showNameInput?: boolean;
+  formAiName?: string;
+  welcomeTitle: string;
+  welcomeDescription: string;
+  showWelcomeOnForm?: boolean;
+  contactSubjectOptions?: string[];
+  getCustomWaitingMessage?: (name?: string) => string;
+  withinBusinessHoursMessage?: string;
+  withinBusinessHoursWaitingMessage?: string;
+  outsideBusinessHoursMessage?: string;
+  outsideBusinessHoursWaitingMessage?: string;
+  withinBusinessHoursFormMessage?: string;
+  outsideBusinessHoursFormMessage?: string;
+  suggestedAIQuestions?: string[];
+  businessHoursPolling?: number;
+  /**
+   * @deprecated This is handled by the BE.
+   */
+  businessHoursStartUTC?: string;
+  /**
+   * @deprecated This is handled by the BE.
+   */
+  businessHoursEndUTC?: string;
+  /**
+   * @deprecated This is handled by the BE.
+   */
+  businessHoursTimezone?: string;
+  showAISuggestionsWithinBusinessHours?: boolean;
+  waitingMessagePosition?: "BEFORE_MESSAGES" | "AFTER_MESSAGES";
+  legalMessage?: string;
+  withinBusinessHoursInitialState?: ChatState;
+  outsideBusinessHoursInitialState?: ChatState;
+  withinBusinessHoursButtontext?: string;
+  outsideBusinessHoursButtontext?: string;
+  reopenChatMessage: string;
+};
+type CustomerServiceIntegration = SimpleCustomerServiceIntegration | FullCustomerServiceIntegration;
+type ConversationalSeach = {
+  enabled?: boolean;
+  replyInput?: ReplyInputConfig;
+  suggestions?: string[];
+  entrypointBgColor?: string;
+  entrypointTextColor?: string;
+  entrypointBtnColor?: string;
+  entrypointBtnTextColor?: string;
+  entrypointBtnBorderColor?: string;
+  entrypointContainer?: string;
+  entrypointTrigger?: string;
+  productGridContainer?: string;
+  generalSearchBtn?: string;
+  pageContent?: string;
+  searchContent?: string;
+  sortingTitle?: string;
+  selectionTitle?: string;
+  sortingFont?: string;
+  optionsFont?: string;
+  sortingButtonText?: string;
+};
+type ChatMessageVariant = "standard" | "premium" | "accent";
+interface ChatMessageConfig {
+  assistantChatTitle: string;
+  variant: ChatMessageVariant;
+  productLink: {
+    variant: ProductLinkVariant;
+    hoverVariant: ProductLinkHoverVariant;
+    iconVariant: ProductLinkIconVariant;
+  };
+}
+interface ReplyInputConfig {
+  size?: "md" | "lg";
+  sendIcon: "arrowUp" | "send" | "search";
+  placeholder?: string;
+}
+interface PartialViewConfig {
+  maxHeight: number;
+  borderRadius?: string;
+}
+type ProductLinkIconVariant = "accentPrimary" | "backgroundPrimary" | "backgroundPrimaryDark" | "borderLight" | "backgroundSaturated";
+type ProductLinkVariant = "textLink";
+type ProductLinkHoverVariant = "backgroundDark";
+type SearchCardVariant = "backgroundPrimary" | "backgroundSecondary" | "backgroundSecondaryDark" | "backgroundLight" | "backgroundSaturated";
+type SuggestionButtonVariant = "outlined" | "outlinedLight" | "primary" | "secondary" | "tertiary" | "dark" | "darkAccent" | "darkPrimary" | "secondaryDark" | "secondaryAccent" | "transparent" | "transparentDark" | "lightDark";
+interface SuggestionButtonConfig {
+  variant?: SuggestionButtonVariant;
+  hoverVariant?: SuggestionButtonVariant;
+  answerVariant?: SuggestionButtonVariant;
+  borderRadius?: "sm" | "md" | "lg";
+}
+type NumRows = "default" | "alwaysOneRow" | "alwaysTwoRows" | "twoRowsOnMobile";
+interface AlphabeticFilterSorting {
+  type: "alphabetic";
+}
+interface ProductCountFilterSorting {
+  type: "productCount";
+}
+interface CustomFilterSorting {
+  type: "custom";
+  map: Record<string, number>;
+}
+type FilterSorting = AlphabeticFilterSorting | ProductCountFilterSorting | CustomFilterSorting;
+interface BaseFilterConfig {
+  filterId: string;
+  displayName: string;
+}
+interface DynamicFilterConfig extends BaseFilterConfig {
+  type: "dynamic";
+  attribute: string;
+  sorting: FilterSorting;
+}
+interface PriceFilterConfig extends BaseFilterConfig {
+  type: "price";
+  bucketSize: number;
+}
+type FilterAttribute = DynamicFilterConfig | PriceFilterConfig;
+type SearchZeroStateVariant = "backgroundTertiary" | "backgroundDark" | "backgroundPrimary";
+type SearchZeroStateLayout = "input" | "icon";
+type SearchInputVariant = "standard";
+type SearchIconVariant = "thin" | "bold";
+type SearchFilterSidebarVariant = "darkButton" | "lightButton";
+type ProductGridVariant = "standard" | "square";
+type UserQueryButtonIcon = "magnifyingGlass" | "send" | "magnifyingGlassThin" | "sendArrow" | "searchIcon";
+interface UserQueryButtonConfig {
+  variant?: "box" | "underlineLight" | "underlineDark";
+  placeholderText?: string;
+  icon: UserQueryButtonIcon;
+}
+interface TermsAndConditionsConfig {
+  copy: string;
+  link: string;
+  linkText: string;
+}
+interface MerchantVariantSettings {
+  dynamicVariants: {
+    enabled: boolean;
+    refreshInterval?: number;
+  };
+}
+interface FloatingChatConfig {
+  enableWatermark: boolean;
+  userQueryInputEnabled: boolean;
+  ignoreFirstModelResponse?: boolean;
+  neverShowSingleProductCards?: boolean;
+  termsAndConditionsConfig?: TermsAndConditionsConfig;
+  suggestionButtonConfig?: SuggestionButtonConfig;
+  replyInputConfig: ReplyInputConfig;
+}
+interface SearchConfig {
+  enableGlobalSearch: boolean;
+  searchFilterConfig: FilterAttribute[];
+  redirectSearchResultsUrl?: string;
+  additiveDynamicFilters?: boolean;
+}
+type OrgUIConfig = {
+  shortName: string;
+  id?: string;
+  floatingEntrypointConfig?: FloatingEntryPointConfig;
+  chatPreviewConfig?: ChatPreviewConfig;
+  customerServiceIntegration: CustomerServiceIntegration;
+  conversationalSearch?: ConversationalSeach;
+  merchantOverrideCss?: string;
+  hiddenElementSelectors?: string[];
+  merchantVariantSettings?: MerchantVariantSettings;
+  floatingChatConfig: FloatingChatConfig;
+  searchConfig: SearchConfig;
+  chatHeader: ChatHeaderConfig;
+  stickyAgentSwitchSuggestion?: boolean;
+  partialViewConfig: PartialViewConfig;
+  welcomeSectionConfig?: WelcomeSectionConfig;
+  productCardConfig?: ProductCardConfig;
+  productReviewConfig?: ProductReviewConfig;
+  pageCardConfig?: PageCardConfig;
+  chatMessageConfig: ChatMessageConfig;
+};
+type InsertionPoint = {
+  selector: string;
+  selectionIndex?: number;
+  insertionType: DOMInsertionType;
+};
+type URLTest = "shopify" | "null";
+type IdExtractor = "shopify-product-id" | "shopify-collection-id" | "shopify-product-variant-id" | "url-resolver-product-id" | "url-resolver-plp-id" | "null";
+declare enum CategoryExtractorType {
+  VisitCategoryMap = "VisitCategoryMap",
+  VisitCategoryDefault = "VisitCategoryDefault",
+}
+interface BaseCategoryExtractor<T extends CategoryExtractorType> {
+  type: T;
+}
+interface VisitCategoryMap extends BaseCategoryExtractor<CategoryExtractorType.VisitCategoryMap> {
+  map: { [key in PageVisitCategory]?: string[] };
+}
+interface VisitCategoryDefault extends BaseCategoryExtractor<CategoryExtractorType.VisitCategoryDefault> {
+  value: PageVisitCategory;
+}
+type CategoryExtractor = VisitCategoryMap | VisitCategoryDefault;
+type WrappingElement = {
+  className: string;
+  element: string;
+  insertionType: DOMInsertionType;
+};
+declare enum PageVariantTestType {
+  ShopifyPLP = "ShopifyPLP",
+  ShopifyPDP = "ShopifyPDP",
+  PageCategory = "PageCategory",
+  CatalogCategory = "CatalogCategory",
+  TopCatalogCategory = "TopCatalogCategory",
+  HasReviews = "HasReviews",
+  InCollection = "InCollection",
+  HasMerchantTag = "HasMerchantTag",
+  FeatureGate = "FeatureGate",
+  PlpId = "PlpId",
+  QueryParam = "QueryParam",
+  ProductId = "ProductId",
+  UserHasInteracted = "UserHasInteracted",
+  UserHasNotInteracted = "UserHasNotInteracted",
+  isLoading = "isLoading",
+  isProductComparison = "isProductComparison",
+  Fallback = "Fallback",
+  UrlResolver = "UrlResolver",
+  Null = "null",
+}
+interface BasePageVariantTest<T extends PageVariantTestType> {
+  testType: T;
+}
+interface TopCatalogCategory extends BasePageVariantTest<PageVariantTestType.TopCatalogCategory> {
+  topCategory: string[];
+}
+interface CatalogCategoryTest extends BasePageVariantTest<PageVariantTestType.CatalogCategory> {
+  category: SupportedEventProductCategory;
+}
+interface HasReviewsTest extends BasePageVariantTest<PageVariantTestType.HasReviews> {
+  reviewMinimum?: number;
+}
+interface InCollectionTest extends BasePageVariantTest<PageVariantTestType.InCollection> {
+  collections: string[];
+}
+interface HasMerchantTagTest extends BasePageVariantTest<PageVariantTestType.HasMerchantTag> {
+  merchantTags: string[];
+}
+interface ShopifyPLPURLTest extends BasePageVariantTest<PageVariantTestType.ShopifyPLP> {}
+interface ShopifyPDPURLTest extends BasePageVariantTest<PageVariantTestType.ShopifyPDP> {}
+interface PageCategoryTest extends BasePageVariantTest<PageVariantTestType.PageCategory> {
+  extractor: CategoryExtractor;
+}
+interface FeatureGateTest extends BasePageVariantTest<PageVariantTestType.FeatureGate> {
+  featureGate: FeatureGates;
+}
+interface ProductIdTest extends BasePageVariantTest<PageVariantTestType.ProductId> {
+  productIdExtractor: IdExtractor;
+  productIds: string[];
+}
+interface PlpIdTest extends BasePageVariantTest<PageVariantTestType.PlpId> {
+  plpIdExtractor: IdExtractor;
+  plpIds: string[];
+}
+interface QueryParamTest extends BasePageVariantTest<PageVariantTestType.QueryParam> {
+  queryParam: string;
+}
+interface UserHasInteractedTest extends BasePageVariantTest<PageVariantTestType.UserHasInteracted> {}
+interface UserHasNotInteractedTest extends BasePageVariantTest<PageVariantTestType.UserHasNotInteracted> {}
+interface IsLoadingTest extends BasePageVariantTest<PageVariantTestType.isLoading> {}
+interface IsProductComparison extends BasePageVariantTest<PageVariantTestType.isProductComparison> {}
+interface PageFallbackTest extends BasePageVariantTest<PageVariantTestType.Fallback> {}
+interface UrlResolverTest extends BasePageVariantTest<PageVariantTestType.UrlResolver> {}
+type PageVariantTest = PageCategoryTest | ShopifyPLPURLTest | ShopifyPDPURLTest | CatalogCategoryTest | TopCatalogCategory | HasReviewsTest | InCollectionTest | HasMerchantTagTest | FeatureGateTest | ProductIdTest | PlpIdTest | QueryParamTest | UserHasInteractedTest | UserHasNotInteractedTest | IsLoadingTest | IsProductComparison | PageFallbackTest | UrlResolverTest;
+/**
+ * Configuration for the social proof embedded widget
+ *
+ * @param headerTitle - The title text to display in the widget header
+ * @param staticSuggestions - A list of strings to display as suggestions in the widget
+ * @param suggestionButtonVariantDefault - The variant of the suggestion button to display in the widget footer
+ * @param suggestionButtonVariantAccent - The variant of the suggestion button to display in the widget body
+ * @param staticImageIndex - Index of the imageUrl to use from the product response
+ */
+interface SocialProofConfig {
+  customerQuery: string;
+  headerTitle: string;
+  staticPLPImagesLayout?: "grid" | "horizontal";
+  headerFontFamily?: string;
+  staticPLPImageNames?: string[];
+  staticImageIndex?: number;
+  suggestionButtonStrings: string[];
+  suggestionButtonVariantDefault: SuggestionButtonVariant;
+  suggestionButtonVariantAccent?: SuggestionButtonVariant;
+  suggestionButtonDataAttributes?: Record<string, string>;
+  userQueryButtonConfig?: UserQueryButtonConfig;
+  logoName?: string;
+}
+/**
+ * Configuration for creating the mount point for a widget
+ *
+ * @param className - Optional class name to apply to the mount point. Tailwind classes are supported
+ * and encouraged. Use this parameter to style the mounting container for the widget.
+ */
+type WidgetMountingConfig = {
+  mountingConfigId: string;
+  containerId: string;
+  testId: string;
+  parentInsertionPoint?: InsertionPoint;
+  insertionPoint: InsertionPoint;
+  gridInsertionType?: GridInsertionType;
+  wrappingElement?: WrappingElement;
+  divCheckSelector?: string;
+  suppressionSelector?: string;
+  style?: Partial<CSSStyleDeclaration>;
+  className?: string;
+  dataAttributes?: Record<string, string>;
+};
+type StaticWidgetMounting = {
+  mountingConfigId: string;
+  widgetConfigId: string;
+};
+type DynamicWidgetMounting = {
+  mountingConfigId: string;
+  mountingPointWidgets: WidgetDisplayTests[];
+};
+type WidgetDisplayTests = {
+  tests: PageVariantTest[];
+  widgetConfigId: string;
+};
+type WidgetMounting = StaticWidgetMounting | DynamicWidgetMounting;
+declare enum WidgetType {
+  ChatPreview = "ChatPreview",
+  SocialProofV2 = "SocialProofV2",
+  ChatPreviewV2 = "ChatPreviewV2",
+  ChatPreviewIsLoading = "ChatPreviewIsLoading",
+  ChatPreviewPostInteraction = "ChatPreviewPostInteraction",
+  ChatPreviewProductComparison = "ChatPreviewProductComparison",
+  SuggestionBar = "SuggestionBar",
+  SuggestionBarV2 = "SuggestionBarV2",
+  ImagePromptCard = "ImagePromptCard",
+  ImageBanner = "ImageBanner",
+  SingleImagePrompt = "SingleImagePrompt",
+  SearchPrompt = "SearchPrompt",
+  SearchZeroStateEntryPoint = "SearchZeroStateEntryPoint",
+  SearchResultsEntryPoint = "SearchResultsEntryPoint",
+  SearchOverlayHost = "SearchOverlayHost",
+  NoOp = "NoOp",
+}
+type WidgetConfig = ChatPreviewWidgetConfig | SocialProofV2WidgetConfig | ChatPreviewV2WidgetConfig | ChatPreviewPostInteractionWidgetConfig | ChatPreviewIsLoadingWidgetConfig | ChatPreviewProductComparisonWidgetConfig | SuggestionBarWidgetV2Config | ImagePromptWidgetConfig | ImageBannerWidgetConfig | SingleImagePromptWidgetConfig | SearchPromptWidgetConfig | SearchEntryPointWidgetConfig | SearchResultsEntryPointWidgetConfig | SearchOverlayHostWidgetConfig | NoOpWidgetConfig;
+interface BaseWidgetConfig<T extends WidgetType> {
+  widgetConfigId: string;
+  type: T;
+  contentId?: string;
+}
+interface ImageBannerWidgetConfig extends BaseWidgetConfig<WidgetType.ImageBanner> {
+  imageSrc: string;
+  title: string;
+  subtitle: string;
+  assistantMessage: string;
+}
+interface ChatPreviewWidgetConfig extends BaseWidgetConfig<WidgetType.ChatPreview> {
+  variant: "filled" | "flat" | "outlined";
+  addSeparators?: boolean;
+  socialProofConfig?: SocialProofConfig;
+  footerConfig?: ChatPreviewFooterConfig;
+}
+interface ChatPreviewHeaderV2Config {
+  title?: string;
+  imageSrc?: string;
+  imageHeight?: number;
+}
+type SingleImageConfig = {
+  layout: "single";
+  imageIndex: number;
+};
+type MultiImageConfig = {
+  layout: "grid" | "horizontal";
+  imageNames: string[];
+};
+type SocialProofImageConfig = SingleImageConfig | MultiImageConfig;
+type ChatPreviewSuggestionButtonConfig = {
+  buttonStrings: string[];
+  accentButtonVariants?: {
+    button: SuggestionButtonVariant;
+    hover: SuggestionButtonVariant;
+  };
+  buttonVariants: {
+    button: SuggestionButtonVariant;
+    hover: SuggestionButtonVariant;
+  };
+  numRows?: NumRows;
+};
+type ChatPreviewAnimatedTextConfig = {
+  leadingText: string;
+  animatedStrings: string[];
+};
+type ChatPreviewVariant = {
+  variant: "flat";
+} | {
+  variant: "filled";
+  backgroundFillColor: string;
+} | {
+  variant: "outlined";
+};
+interface BaseChatPreviewConfig {
+  headerConfig: ChatPreviewHeaderV2Config;
+  suggestionButtonsConfig: ChatPreviewSuggestionButtonConfig;
+  userQueryButtonConfig: UserQueryButtonConfig;
+  chatPreviewVariant: ChatPreviewVariant;
+  addSeparators?: boolean;
+}
+interface ChatPreviewPostInteractionWidgetConfig extends BaseWidgetConfig<WidgetType.ChatPreviewPostInteraction>, BaseChatPreviewConfig {
+  chatPreviewVariant: ChatPreviewVariant;
+  addSeparators?: boolean;
+}
+interface ChatPreviewIsLoadingWidgetConfig extends BaseWidgetConfig<WidgetType.ChatPreviewIsLoading>, BaseChatPreviewConfig {}
+interface ChatPreviewProductComparisonWidgetConfig extends BaseWidgetConfig<WidgetType.ChatPreviewProductComparison>, BaseChatPreviewConfig {
+  useLargeProductComparison?: boolean;
+}
+interface ChatPreviewV2WidgetConfig extends BaseWidgetConfig<WidgetType.ChatPreviewV2>, BaseChatPreviewConfig {
+  animatedTextConfig: ChatPreviewAnimatedTextConfig;
+}
+interface SocialProofV2WidgetConfig extends BaseWidgetConfig<WidgetType.SocialProofV2>, BaseChatPreviewConfig {
+  customerQuery?: string;
+  imageConfig: SocialProofImageConfig;
+}
+interface SuggestionBarWidgetV2Config extends BaseWidgetConfig<WidgetType.SuggestionBarV2> {
+  metricDisplayLocation: ChatElementDisplayLocation;
+  location: SuggestionBarLocationForMetrics;
+  variant: SuggestionButtonVariant;
+  hoverVariant: SuggestionButtonVariant;
+  buttonTexts: {
+    default: string[];
+    productSpecific?: {
+      [productId: string]: string[];
+    };
+  };
+  boldFirstButton?: boolean;
+  twoRowsOnMobile?: boolean;
+  animationSpeed?: "standard" | "slow" | "none";
+  buttonBorderRadius?: "sm" | "md" | "lg";
+}
+interface ImagePromptWidgetConfig extends BaseWidgetConfig<WidgetType.ImagePromptCard> {
+  url: string;
+  lightText?: boolean;
+  title: string;
+  subtitle: string[];
+  staticSuggestionCopies: string[];
+  userQueryButtonConfig: UserQueryButtonConfig;
+  fallbackBackgroundColor?: string;
+}
+interface SingleImagePromptWidgetConfig extends BaseWidgetConfig<WidgetType.SingleImagePrompt> {
+  title: string;
+  staticSuggestionCopies: string[];
+  userQueryButtonConfig: UserQueryButtonConfig;
+}
+interface SearchEntryPointWidgetConfig extends BaseWidgetConfig<WidgetType.SearchZeroStateEntryPoint> {
+  searchZeroStateVariant: SearchZeroStateVariant;
+  searchInputVariant: SearchInputVariant;
+  searchIconVariant?: SearchIconVariant;
+  searchIconSize?: number;
+  suggestionButtonConfig: SuggestionButtonConfig;
+  layout: SearchZeroStateLayout;
+  searchBoxPlaceholder: string;
+  animationSpeed?: "standard" | "slow" | "none";
+  compactLabel?: string;
+  initialSuggestions?: string[];
+  usingPortal?: boolean;
+}
+interface NoOpWidgetConfig extends BaseWidgetConfig<WidgetType.NoOp> {}
+interface SearchOverlayHostWidgetConfig extends BaseWidgetConfig<WidgetType.SearchOverlayHost> {}
+interface SearchResultsEntryPointWidgetConfig extends BaseWidgetConfig<WidgetType.SearchResultsEntryPoint> {
+  searchInputVariant: SearchInputVariant;
+  searchFilterSidebarVariant: SearchFilterSidebarVariant;
+  productGridVariant: ProductGridVariant;
+  searchBoxPlaceholder: string;
+  noResultsFoundText?: string;
+}
+interface WidgetHeaderProps extends TestProps {
+  title?: string;
+  logo?: string;
+  logoHeight?: number;
+  orgShortName: string;
+  variant?: SearchPromptVariant;
+}
+interface UserQueryOptions {
+  footerVariant?: "standard";
+  replyButtonText?: string;
+  replyButtonIcon?: "magnifyingGlass" | "send" | "thinMagnifyingGlass" | "ai-search";
+}
+type SearchPromptVariant = "primary";
+interface SearchPromptWidgetConfig extends BaseWidgetConfig<WidgetType.SearchPrompt> {
+  variant: SearchPromptVariant;
+  title: string;
+  headerConfig: WidgetHeaderProps;
+  suggestionButtons: {
+    variant: SuggestionButtonVariant;
+    hoverVariant: SuggestionButtonVariant;
+    buttonTexts: string[];
+  };
+  footerConfig?: UserQueryOptions;
+}
+type PageVariantBase = {
+  variantId: string;
+  widgetMounting: WidgetMounting[];
+  variantTests: PageVariantTest[];
+};
+type PLPPageVariant = PageVariantBase & {
+  variantType: "plp";
+  plpIdExtractor: IdExtractor;
+};
+type PDPPageVariant = PageVariantBase & {
+  variantType: "pdp";
+  parentProductIdExtractor?: IdExtractor;
+  productIdExtractor: IdExtractor;
+};
+type VisitPageVariant = PageVariantBase & {
+  variantType: "page_visit";
+};
+type OtherPageVariant = PageVariantBase & {
+  variantType: "other";
+};
+type HomePageVariant = PageVariantBase & {
+  variantType: "homepage";
+};
+type SearchPageVariant = PageVariantBase & {
+  variantType: "search";
+};
+type PageVariantConfig = PLPPageVariant | PDPPageVariant | VisitPageVariant | OtherPageVariant | HomePageVariant | SearchPageVariant;
+type OrgPageConfig = {
+  pageVariants: PageVariantConfig[];
+  widgetConfigs: Record<string, WidgetConfig>;
+  mountingConfigs: Record<string, WidgetMountingConfig>;
+};
+interface OrgConfigContextType {
+  orgUIConfig: OrgUIConfig;
+}
+type OrgConfig$1 = OrgUIConfig;
+interface EnviveConfig {
+  amplitudeApiKey?: string;
+  dataResidency?: string;
+  env?: string;
+  baseUrl?: string;
+  reactAppName?: string;
+  cdnUrl?: string;
+  contextSource?: string;
+  orgLevelApiKey?: string;
+  orgShortName?: string;
+  identifyingPrefix?: string;
+}
+//#endregion
+//#region src/application/models/frontendConfig.d.ts
+interface FrontendConfig {
+  merchantOverrideCss?: string;
+  pageVariants?: PageVariantConfig[];
+  mountingConfigs?: Record<string, WidgetMountingConfig>;
+  widgetConfigs?: Record<string, WidgetConfig>;
+  uiConfigs?: Omit<OrgUIConfig, 'merchantOverrideCss'>;
+}
+//#endregion
+//#region src/application/models/api/orgConfigResults.d.ts
+interface OrgConfigExperiment {
+  group?: string;
+  groupName?: string;
+  name?: string;
+  ruleId?: string;
+  value?: Record<string, unknown>;
+}
+interface OrgConfigFeatureGate {
+  groupName?: string;
+  name?: string;
+  ruleId?: string;
+  value?: boolean;
+}
+interface Organization {
+  id: string;
+  displayName: string;
+  domain: string;
+  shortName: string;
+  status: OrganizationStatusEnum;
+  createdAt?: string;
+  updatedAt?: string;
+}
+interface OrganizationSettings$1 {
+  org: Organization;
+  settings: Record<string, unknown>;
+}
+interface OrgConfig {
+  configs: OrganizationConfig$1[];
+  experiments: OrgConfigExperiment[];
+  gates: OrgConfigFeatureGate[];
+  org: OrganizationSettings$1;
+  colorsConfig?: ColorMapping;
+  frontendConfig?: FrontendConfig;
+}
+//#endregion
+export { type CategoryExtractor, CategoryExtractorType, ChatElementDisplayLocation, type ChatMessageConfig, type ChatMessageVariant, type ChatPreviewConfig, type ChatPreviewFooterConfig, type ChatPreviewHeaderConfig, type ChatPreviewHeaderV2Config, type ChatPreviewIsLoadingWidgetConfig, type ChatPreviewPostInteractionWidgetConfig, type ChatPreviewProductComparisonWidgetConfig, type ChatPreviewSuggestionButtonConfig, type ChatPreviewV2WidgetConfig, type ChatPreviewVariant, type ChatPreviewWidgetConfig, type ColorMapping, ColorNames, type CustomerServiceIntegration, DOMInsertionService, DOMInsertionType, DOMInsertionTypeToInsertPosition, type DynamicWidgetMounting, EnviveConfig, FeatureGates, FilterAttribute, type FloatingEntryPointConfig, FrontendConfig, type FullCustomerServiceIntegration, GridInsertionService, GridInsertionType, type HomePageVariant, type IdExtractor, type ImageBannerWidgetConfig, type ImagePromptWidgetConfig, type InsertionPoint, type MultiImageConfig, type NoOpWidgetConfig, type NumRows, OrgAnalyticsAmplitudeConfig, OrgAnalyticsConfig, OrgAnalyticsCustomerServiceConfig, OrgAnalyticsGoogleAnalyticsConfig, OrgConfig, OrgConfig$1, type OrgConfigContextType, OrgConfigExperiment, OrgConfigFeatureGate, OrgPageConfig, type OrgUIConfig, Organization, OrganizationConfig$1 as OrganizationConfig, OrganizationSettings$1 as OrganizationSettings, type OtherPageVariant, type PDPPageVariant, type PLPPageVariant, type PageCardConfig, type PageCardHoverVariant, type PageCardIconVariant, type PageCardVariant, PageVariantConfig, PageVariantTest, PageVariantTestType, type ProductCardConfig, type ProductCardHoverVariant, type ProductCardLayoutVariant, type ProductCardVariant, ProductGridVariant, type ProductLinkHoverVariant, type ProductLinkIconVariant, type ProductLinkVariant, type ProductReviewColorVariant, type ProductReviewConfig, type ProductReviewStyleVariant, type SearchCardVariant, type SearchEntryPointWidgetConfig, SearchFilterSidebarVariant, SearchIconVariant, SearchInputVariant, type SearchOverlayHostWidgetConfig, type SearchPageVariant, type SearchPromptVariant, type SearchPromptWidgetConfig, type SearchResultsEntryPointWidgetConfig, SearchZeroStateLayout, SearchZeroStateVariant, type ShowFloatingButtonOptions, type SingleImagePromptWidgetConfig, type SocialProofConfig, type SocialProofV2WidgetConfig, type StaticWidgetMounting, type SuggestionBarWidgetV2Config, type SuggestionButtonConfig, type SuggestionButtonVariant, type URLTest, type UserQueryButtonConfig, type UserQueryButtonIcon, UserQueryOptions, type VisitPageVariant, type WelcomeSectionColorVariant, type WelcomeSectionConfig, type WelcomeSectionVariant, type WidgetConfig, type WidgetDisplayTests, WidgetHeaderProps, type WidgetMounting, WidgetMountingConfig, WidgetType, type WrappingElement, colorVar };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"orgConfigResults-BL0XBA6x.d.cts","names":[],"sources":["../src/application/models/api/orgAnalyticsConfig.d.ts","../src/application/models/api/organizationConfig.d.ts","../src/application/models/colorsConfig.d.ts","../src/application/models/chatElementDisplayLocation.d.ts","../src/application/models/featureGates.d.ts","../src/application/service/domMutations/domInsertionService.d.ts","../src/application/service/domMutations/GridInsertionService.d.ts","../src/contexts/types.d.ts","../src/application/models/frontendConfig.d.ts","../src/application/models/api/orgConfigResults.d.ts"],"sourcesContent":["export interface OrgAnalyticsConfig {\n    amplitude?: OrgAnalyticsAmplitudeConfig;\n    customerService?: OrgAnalyticsCustomerServiceConfig;\n    googleAnalytics?: OrgAnalyticsGoogleAnalyticsConfig;\n}\nexport interface OrgAnalyticsAmplitudeConfig {\n    sessionReplayEnabled: boolean;\n    sessionReplaySampleRate: number;\n    trackingEnabled: boolean;\n}\nexport interface OrgAnalyticsCustomerServiceConfig {\n    provider: string;\n}\nexport interface OrgAnalyticsGoogleAnalyticsConfig {\n    measurementId?: string;\n}\n","import { OrgAnalyticsConfig } from './orgAnalyticsConfig';\nexport interface OrganizationConfig {\n    createdAt: string;\n    namespace: string;\n    isLatest: boolean;\n    version: string;\n    updatedAt: string;\n    config: OrgAnalyticsConfig;\n    organizationId?: string;\n    id?: string;\n}\n","declare enum ColorNames {\n    TextPrimary = \"text-primary\",\n    TextSecondary = \"text-secondary\",\n    TextAccent = \"text-accent\",\n    TextLink = \"text-link\",\n    TextLight = \"text-light\",\n    BackgroundPrimary = \"background-primary\",\n    BackgroundSecondary = \"background-secondary\",\n    BackgroundSecondaryDark = \"background-secondary-dark\",\n    BackgroundTertiary = \"background-tertiary\",\n    BackgroundDark = \"background-dark\",\n    BackgroundLight = \"background-light\",\n    BackgroundSaturated = \"background-saturated\",\n    BorderLight = \"border-light\",\n    BorderMedium = \"border-medium\",\n    BorderDark = \"border-dark\",\n    BorderOutline = \"border-outline\",\n    AccentPrimary = \"accent-primary\",\n    AccentSecondary = \"accent-secondary\"\n}\ntype ColorMapping = {\n    [key in ColorNames]: string;\n};\ndeclare const colorVar: (color: ColorNames) => string;\nexport { ColorNames, colorVar };\nexport type { ColorMapping };\n","export declare enum ChatElementDisplayLocation {\n    IN_CHAT = \"in_chat\",\n    CHAT_PREVIEW = \"chat_preview\",\n    FLOATING_BUTTON = \"floating_button\",\n    HELP_ME_CHOOSE = \"help_me_choose\",\n    PLP_IMAGE_BANNER = \"plp_image_banner\",\n    TOP_REVIEWS_SNIPPET = \"top_reviews_snippet\",\n    BOTTOM_REVIEWS_SNIPPET = \"bottom_reviews_snippet\",\n    BLOCK_BACK_BUTTON = \"block_back_button\",\n    SWITCH_TO_AGENT = \"switch_to_agent\",\n    CONVERSATIONAL_SEARCH = \"conversational_search\",\n    GLOBAL_SEARCH_ENTRYPOINT = \"global_search_entrypoint\",\n    SEARCH_NAV_ENTRYPOINT = \"search_nav_entrypoint\",\n    SEARCH_PROMPT = \"search_prompt\",\n    SEARCH_PROMPT_BUTTON = \"search_prompt_button\",\n    PRODUCT_GRID = \"product_grid\",\n    UNSPECIFIED = \"unspecified\",\n    FILTER_MODAL = \"filter_modal\",\n    PROMPT_CARD = \"prompt_card\",\n    WINDOW_API_CALL = \"window_api_call\"\n}\n","export declare enum FeatureGates {\n    IsClientSessionEnabled = \"is_client_session_enabled\",\n    IsNewFeatureEnabled = \"is_new_feature_enabled\",\n    IsFineTunedModel8b = \"is_fine_tuned_model_8b\",\n    IsIntegratedCXEnabled = \"is_integrated_cx_enabled\",\n    IsNonShapewearEnabled = \"is_non_shapewear_enabled\",\n    IsImageBannerEnabled = \"is_image_banner_enabled\",\n    IsOrderLookupEnabled = \"is_order_lookup_enabled\",\n    IsSummarizeReviewsEnabled = \"is_summarize_reviews_enabled\",\n    IsGlobalSearchEnabled = \"is_global_search_enabled\",\n    IsImagePromptEnabled = \"is_image_prompt_enabled\",\n    IsWatermarkEnabled = \"is_watermark_enabled\",\n    IsInferenceRegion0 = \"is_inference_region_0\",\n    IsGraphQLUIConfigsEnabled = \"is_graphql_ui_configs_enabled\",\n    IsGraphQLPageConfigsEnabled = \"is_graphql_page_configs_enabled\",\n    IsGraphQLComponentConfigsEnabled = \"is_graphql_component_configs_enabled\",\n    IsChatVariantEnabled = \"is_chat_variant_enabled\",\n    IsChatVariantAEnabled = \"is_chat_variant_a_enabled\",\n    IsChatVariantBEnabled = \"is_chat_variant_b_enabled\",\n    IsUserQueryAlwaysEnabled = \"is_user_query_always_enabled\"\n}\n","declare enum DOMInsertionType {\n    AFTER = \"after\",\n    BEFORE = \"before\",\n    ADJACENT_AFTER_BEGIN = \"adjacent-after-begin\",\n    ADJACENT_BEFORE_BEGIN = \"adjacent-before-begin\",\n    ADJACENT_AFTER_END = \"adjacent-after-end\",\n    ADJACENT_BEFORE_END = \"adjacent-before-end\",\n    APPEND_CHILD = \"append-child\",\n    NONE = \"none\"\n}\nexport declare const DOMInsertionTypeToInsertPosition: (type: DOMInsertionType) => InsertPosition;\ndeclare class DOMInsertionService {\n    static insert(targetElement: Element, nodeToInsert: HTMLElement, insertionType: DOMInsertionType): void;\n    /**\n     * Get the insertion point for the widget.\n     * @param selector - The selector to find the insertion point.\n     * @param selectionIndex - For multiple matches, pick the nth element. Can be negative to insert from the end (-1 is the last element). (optional, default first)\n     * @returns The insertion point element or null if not found.\n     */\n    static getInsertionPoint(selector: string, selectionIndex?: number): Element | null;\n}\nexport { DOMInsertionService, DOMInsertionType };\n","import { DOMInsertionType } from 'src/application/service/domMutations/domInsertionService';\ndeclare enum GridInsertionType {\n    FIXED_1 = \"fixed-1\",\n    FIXED_2 = \"fixed-2\",\n    FIXED_3 = \"fixed-3\",\n    FIXED_4 = \"fixed-4\",\n    FIXED_5 = \"fixed-5\",\n    FIXED_6 = \"fixed-6\",\n    FIXED_7 = \"fixed-7\",\n    FIXED_8 = \"fixed-8\",\n    FIXED_9 = \"fixed-9\",\n    FIXED_12 = \"fixed-12\",\n    FIXED_13 = \"fixed-13\",\n    ROW_1 = \"row-1\",\n    ROW_2 = \"row-2\",\n    ROW_3 = \"row-3\",\n    ROW_4 = \"row-4\"\n}\ndeclare class GridInsertionService {\n    static insert(gridInsertionType: GridInsertionType, targetElement: Element, nodeToInsert: HTMLElement, insertionType: DOMInsertionType): void;\n    /**\n     * Inserts a node into a grid row at the specified index starting from index 1. If the index\n     * is higher than the total number of rows, the node will be inserted at the end of the grid.\n     * This function does not make any assumptions about the column span of the inserted node - that\n     * should be handled by the orgConfig instead.\n     *\n     * @param targetElement - The target element to insert the node into.\n     * @param nodeToInsert - The node to insert into the grid.\n     * @param rowIndex - The index of the row to insert the node into.\n     */\n    static rowInsert(targetElement: Element, nodeToInsert: HTMLElement, rowIndex: number): void;\n    static fixedInsert(targetElement: Element, insertionGridIndex: number, nodeToInsert: HTMLElement, insertionType: DOMInsertionType): void;\n}\nexport { GridInsertionType, GridInsertionService };\n","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/application/service/customerService/types\";\nimport { GridInsertionType } from \"src/application/service/domMutations/GridInsertionService\";\nimport { DOMInsertionType } from \"src/application/service/domMutations/domInsertionService\";\nimport type { PageVisitCategory, SupportedEventProductCategory } 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\";\ntype ShowFloatingButtonOptions = \"always\" | \"after-interaction-on-mobile-always-desktop\" | \"after-interaction-anywhere\" | \"never\";\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};\ntype WelcomeSectionVariant = \"standard\" | \"outlined\";\ntype WelcomeSectionColorVariant = \"standard\" | \"accent\" | \"brand\" | \"light\";\ntype WelcomeSectionConfig = {\n    variant: WelcomeSectionVariant;\n    colorVariant?: WelcomeSectionColorVariant;\n    title?: string;\n    subtitle?: string;\n    iconName?: string;\n    imageSrc?: string;\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: {\n        pdp: string[];\n        plp: string[];\n    };\n    staticSuggestionCopies?: {\n        pdp: string[];\n        plp: string[];\n    };\n    staticPLPImages?: string[];\n    footerConfig?: ChatPreviewFooterConfig;\n    headerConfig?: ChatPreviewHeaderConfig;\n    topMargin?: number;\n};\ntype ChatPreviewHeaderConfig = {\n    title?: string;\n    imageSrc?: string;\n    imageHeight?: number;\n    sparklesColor?: string;\n    fontSize?: string;\n    iconWidth?: string;\n    iconHeight?: string;\n};\ninterface ChatPreviewFooterConfig {\n    hasFade?: boolean;\n    suggestionButtonVariant?: \"dark\" | \"light\" | \"outlined\";\n    suggestionsBackground?: string;\n    replyButtonIcon?: \"send\" | \"magnifyingGlass\" | \"thinMagnifyingGlass\" | \"searchIcon\";\n    replyButtonText?: string;\n    replyInputHasShadow?: boolean;\n    replyInputHasBorder?: boolean;\n    backgroundColor?: string;\n}\ntype ProductReviewStyleVariant = \"standard\" | \"bordered\";\ntype ProductReviewColorVariant = \"neutral\" | \"brand\" | \"premium\";\ninterface ProductReviewConfig {\n    styleVariant: ProductReviewStyleVariant;\n    colorVariant: ProductReviewColorVariant;\n    verifiedBuyerTitle: string;\n    incentivizedReviewFlag?: boolean;\n}\ntype PageCardVariant = \"filled\" | \"outlined\" | \"minimal\";\ntype PageCardHoverVariant = \"none\" | \"shadow\" | \"lift\";\ntype PageCardIconVariant = \"primary\" | \"accent\" | \"background\" | \"none\";\ntype PageCardConfig = {\n    variant: PageCardVariant;\n    hoverVariant: PageCardHoverVariant;\n    iconVariant: PageCardIconVariant;\n};\ntype ProductCardVariant = \"filled\" | \"bordered\" | \"minimal\" | \"transparentBordered\";\ntype ProductCardHoverVariant = \"backgroundDark\" | \"none\";\ntype ProductCardLayoutVariant = \"normal\" | \"tall\" | \"square\";\ninterface ProductCardConfig {\n    variant: ProductCardVariant;\n    hoverVariant: ProductCardHoverVariant;\n    layoutVariant: ProductCardLayoutVariant;\n    pricePrefix?: string;\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};\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};\ntype SimpleCustomerServiceIntegration = {\n    integrationMode: CustomerServiceIntegrationMode;\n    provider: CustomerServiceType;\n    useUnifiedButton?: boolean;\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    /**\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    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};\ntype CustomerServiceIntegration = SimpleCustomerServiceIntegration | FullCustomerServiceIntegration;\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};\ntype ChatMessageVariant = \"standard\" | \"premium\" | \"accent\";\ninterface ChatMessageConfig {\n    assistantChatTitle: string;\n    variant: ChatMessageVariant;\n    productLink: {\n        variant: ProductLinkVariant;\n        hoverVariant: ProductLinkHoverVariant;\n        iconVariant: ProductLinkIconVariant;\n    };\n}\ninterface ReplyInputConfig {\n    size?: \"md\" | \"lg\";\n    sendIcon: \"arrowUp\" | \"send\" | \"search\";\n    placeholder?: string;\n}\ninterface PartialViewConfig {\n    maxHeight: number;\n    borderRadius?: string;\n}\ntype ProductLinkIconVariant = \"accentPrimary\" | \"backgroundPrimary\" | \"backgroundPrimaryDark\" | \"borderLight\" | \"backgroundSaturated\";\ntype ProductLinkVariant = \"textLink\";\ntype ProductLinkHoverVariant = \"backgroundDark\";\ntype SearchCardVariant = \"backgroundPrimary\" | \"backgroundSecondary\" | \"backgroundSecondaryDark\" | \"backgroundLight\" | \"backgroundSaturated\";\ntype SuggestionButtonVariant = \"outlined\" | \"outlinedLight\" | \"primary\" | \"secondary\" | \"tertiary\" | \"dark\" | \"darkAccent\" | \"darkPrimary\" | \"secondaryDark\" | \"secondaryAccent\" | \"transparent\" | \"transparentDark\" | \"lightDark\";\ninterface SuggestionButtonConfig {\n    variant?: SuggestionButtonVariant;\n    hoverVariant?: SuggestionButtonVariant;\n    answerVariant?: SuggestionButtonVariant;\n    borderRadius?: \"sm\" | \"md\" | \"lg\";\n}\ntype NumRows = \"default\" | \"alwaysOneRow\" | \"alwaysTwoRows\" | \"twoRowsOnMobile\";\ninterface AlphabeticFilterSorting {\n    type: \"alphabetic\";\n}\ninterface ProductCountFilterSorting {\n    type: \"productCount\";\n}\ninterface CustomFilterSorting {\n    type: \"custom\";\n    map: Record<string, number>;\n}\ntype FilterSorting = AlphabeticFilterSorting | ProductCountFilterSorting | CustomFilterSorting;\ninterface BaseFilterConfig {\n    filterId: string;\n    displayName: string;\n}\ninterface DynamicFilterConfig extends BaseFilterConfig {\n    type: \"dynamic\";\n    attribute: string;\n    sorting: FilterSorting;\n}\ninterface PriceFilterConfig extends BaseFilterConfig {\n    type: \"price\";\n    bucketSize: number;\n}\nexport type FilterAttribute = DynamicFilterConfig | PriceFilterConfig;\nexport type SearchZeroStateVariant = \"backgroundTertiary\" | \"backgroundDark\" | \"backgroundPrimary\";\nexport type SearchZeroStateLayout = \"input\" | \"icon\";\nexport type SearchInputVariant = \"standard\";\nexport type SearchIconVariant = \"thin\" | \"bold\";\nexport type SearchFilterSidebarVariant = \"darkButton\" | \"lightButton\";\nexport type ProductGridVariant = \"standard\" | \"square\";\ntype UserQueryButtonIcon = \"magnifyingGlass\" | \"send\" | \"magnifyingGlassThin\" | \"sendArrow\" | \"searchIcon\";\ninterface UserQueryButtonConfig {\n    variant?: \"box\" | \"underlineLight\" | \"underlineDark\";\n    placeholderText?: string;\n    icon: UserQueryButtonIcon;\n}\ninterface TermsAndConditionsConfig {\n    copy: string;\n    link: string;\n    linkText: string;\n}\ninterface MerchantVariantSettings {\n    dynamicVariants: {\n        enabled: boolean;\n        refreshInterval?: number;\n    };\n}\ninterface FloatingChatConfig {\n    enableWatermark: boolean;\n    userQueryInputEnabled: boolean;\n    ignoreFirstModelResponse?: boolean;\n    neverShowSingleProductCards?: boolean;\n    termsAndConditionsConfig?: TermsAndConditionsConfig;\n    suggestionButtonConfig?: SuggestionButtonConfig;\n    replyInputConfig: ReplyInputConfig;\n}\ninterface SearchConfig {\n    enableGlobalSearch: boolean;\n    searchFilterConfig: FilterAttribute[];\n    redirectSearchResultsUrl?: string;\n    additiveDynamicFilters?: boolean;\n}\ntype OrgUIConfig = {\n    shortName: string;\n    id?: string;\n    floatingEntrypointConfig?: FloatingEntryPointConfig;\n    chatPreviewConfig?: ChatPreviewConfig;\n    customerServiceIntegration: CustomerServiceIntegration;\n    conversationalSearch?: ConversationalSeach;\n    merchantOverrideCss?: string;\n    hiddenElementSelectors?: string[];\n    merchantVariantSettings?: MerchantVariantSettings;\n    floatingChatConfig: FloatingChatConfig;\n    searchConfig: SearchConfig;\n    chatHeader: ChatHeaderConfig;\n    stickyAgentSwitchSuggestion?: boolean;\n    partialViewConfig: PartialViewConfig;\n    welcomeSectionConfig?: WelcomeSectionConfig;\n    productCardConfig?: ProductCardConfig;\n    productReviewConfig?: ProductReviewConfig;\n    pageCardConfig?: PageCardConfig;\n    chatMessageConfig: ChatMessageConfig;\n};\ntype InsertionPoint = {\n    selector: string;\n    selectionIndex?: number;\n    insertionType: DOMInsertionType;\n};\ntype URLTest = \"shopify\" | \"null\";\ntype IdExtractor = \"shopify-product-id\" | \"shopify-collection-id\" | \"shopify-product-variant-id\" | \"url-resolver-product-id\" | \"url-resolver-plp-id\" | \"null\";\ndeclare enum CategoryExtractorType {\n    VisitCategoryMap = \"VisitCategoryMap\",\n    VisitCategoryDefault = \"VisitCategoryDefault\"\n}\ninterface BaseCategoryExtractor<T extends CategoryExtractorType> {\n    type: T;\n}\ninterface VisitCategoryMap extends BaseCategoryExtractor<CategoryExtractorType.VisitCategoryMap> {\n    map: {\n        [key in PageVisitCategory]?: string[];\n    };\n}\ninterface VisitCategoryDefault extends BaseCategoryExtractor<CategoryExtractorType.VisitCategoryDefault> {\n    value: PageVisitCategory;\n}\ntype CategoryExtractor = VisitCategoryMap | VisitCategoryDefault;\ntype WrappingElement = {\n    className: string;\n    element: string;\n    insertionType: DOMInsertionType;\n};\ndeclare enum 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}\ninterface BasePageVariantTest<T extends PageVariantTestType> {\n    testType: T;\n}\ninterface TopCatalogCategory extends BasePageVariantTest<PageVariantTestType.TopCatalogCategory> {\n    topCategory: string[];\n}\ninterface CatalogCategoryTest extends BasePageVariantTest<PageVariantTestType.CatalogCategory> {\n    category: SupportedEventProductCategory;\n}\ninterface HasReviewsTest extends BasePageVariantTest<PageVariantTestType.HasReviews> {\n    reviewMinimum?: number;\n}\ninterface InCollectionTest extends BasePageVariantTest<PageVariantTestType.InCollection> {\n    collections: string[];\n}\ninterface HasMerchantTagTest extends BasePageVariantTest<PageVariantTestType.HasMerchantTag> {\n    merchantTags: string[];\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}\ninterface FeatureGateTest extends BasePageVariantTest<PageVariantTestType.FeatureGate> {\n    featureGate: FeatureGates;\n}\ninterface ProductIdTest extends BasePageVariantTest<PageVariantTestType.ProductId> {\n    productIdExtractor: IdExtractor;\n    productIds: string[];\n}\ninterface PlpIdTest extends BasePageVariantTest<PageVariantTestType.PlpId> {\n    plpIdExtractor: IdExtractor;\n    plpIds: string[];\n}\ninterface QueryParamTest extends BasePageVariantTest<PageVariantTestType.QueryParam> {\n    queryParam: string;\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 = PageCategoryTest | ShopifyPLPURLTest | ShopifyPDPURLTest | CatalogCategoryTest | TopCatalogCategory | HasReviewsTest | InCollectionTest | HasMerchantTagTest | FeatureGateTest | ProductIdTest | PlpIdTest | QueryParamTest | UserHasInteractedTest | UserHasNotInteractedTest | IsLoadingTest | IsProductComparison | PageFallbackTest | UrlResolverTest;\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 * 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};\ntype StaticWidgetMounting = {\n    mountingConfigId: string;\n    widgetConfigId: string;\n};\ntype DynamicWidgetMounting = {\n    mountingConfigId: string;\n    mountingPointWidgets: WidgetDisplayTests[];\n};\ntype WidgetDisplayTests = {\n    tests: PageVariantTest[];\n    widgetConfigId: string;\n};\ntype WidgetMounting = StaticWidgetMounting | DynamicWidgetMounting;\ndeclare enum 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}\ntype WidgetConfig = ChatPreviewWidgetConfig | SocialProofV2WidgetConfig | ChatPreviewV2WidgetConfig | ChatPreviewPostInteractionWidgetConfig | ChatPreviewIsLoadingWidgetConfig | ChatPreviewProductComparisonWidgetConfig | SuggestionBarWidgetV2Config | ImagePromptWidgetConfig | ImageBannerWidgetConfig | SingleImagePromptWidgetConfig | SearchPromptWidgetConfig | SearchEntryPointWidgetConfig | SearchResultsEntryPointWidgetConfig | SearchOverlayHostWidgetConfig | NoOpWidgetConfig;\ninterface BaseWidgetConfig<T extends WidgetType> {\n    widgetConfigId: string;\n    type: T;\n    contentId?: string;\n}\ninterface ImageBannerWidgetConfig extends BaseWidgetConfig<WidgetType.ImageBanner> {\n    imageSrc: string;\n    title: string;\n    subtitle: string;\n    assistantMessage: string;\n}\ninterface ChatPreviewWidgetConfig extends BaseWidgetConfig<WidgetType.ChatPreview> {\n    variant: \"filled\" | \"flat\" | \"outlined\";\n    addSeparators?: boolean;\n    socialProofConfig?: SocialProofConfig;\n    footerConfig?: ChatPreviewFooterConfig;\n}\ninterface ChatPreviewHeaderV2Config {\n    title?: string;\n    imageSrc?: string;\n    imageHeight?: number;\n}\ntype SingleImageConfig = {\n    layout: \"single\";\n    imageIndex: number;\n};\ntype MultiImageConfig = {\n    layout: \"grid\" | \"horizontal\";\n    imageNames: string[];\n};\ntype SocialProofImageConfig = SingleImageConfig | MultiImageConfig;\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};\ntype ChatPreviewAnimatedTextConfig = {\n    leadingText: string;\n    animatedStrings: string[];\n};\ntype ChatPreviewVariant = {\n    variant: \"flat\";\n} | {\n    variant: \"filled\";\n    backgroundFillColor: string;\n} | {\n    variant: \"outlined\";\n};\ninterface BaseChatPreviewConfig {\n    headerConfig: ChatPreviewHeaderV2Config;\n    suggestionButtonsConfig: ChatPreviewSuggestionButtonConfig;\n    userQueryButtonConfig: UserQueryButtonConfig;\n    chatPreviewVariant: ChatPreviewVariant;\n    addSeparators?: boolean;\n}\ninterface ChatPreviewPostInteractionWidgetConfig extends BaseWidgetConfig<WidgetType.ChatPreviewPostInteraction>, BaseChatPreviewConfig {\n    chatPreviewVariant: ChatPreviewVariant;\n    addSeparators?: boolean;\n}\ninterface ChatPreviewIsLoadingWidgetConfig extends BaseWidgetConfig<WidgetType.ChatPreviewIsLoading>, BaseChatPreviewConfig {\n}\ninterface ChatPreviewProductComparisonWidgetConfig extends BaseWidgetConfig<WidgetType.ChatPreviewProductComparison>, BaseChatPreviewConfig {\n    useLargeProductComparison?: boolean;\n}\ninterface ChatPreviewV2WidgetConfig extends BaseWidgetConfig<WidgetType.ChatPreviewV2>, BaseChatPreviewConfig {\n    animatedTextConfig: ChatPreviewAnimatedTextConfig;\n}\ninterface SocialProofV2WidgetConfig extends BaseWidgetConfig<WidgetType.SocialProofV2>, BaseChatPreviewConfig {\n    customerQuery?: string;\n    imageConfig: SocialProofImageConfig;\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?: {\n            [productId: string]: string[];\n        };\n    };\n    boldFirstButton?: boolean;\n    twoRowsOnMobile?: boolean;\n    animationSpeed?: \"standard\" | \"slow\" | \"none\";\n    buttonBorderRadius?: \"sm\" | \"md\" | \"lg\";\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}\ninterface SingleImagePromptWidgetConfig extends BaseWidgetConfig<WidgetType.SingleImagePrompt> {\n    title: string;\n    staticSuggestionCopies: string[];\n    userQueryButtonConfig: UserQueryButtonConfig;\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}\ninterface NoOpWidgetConfig extends BaseWidgetConfig<WidgetType.NoOp> {\n}\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}\nexport interface WidgetHeaderProps extends TestProps {\n    title?: string;\n    logo?: string;\n    logoHeight?: number;\n    orgShortName: string;\n    variant?: SearchPromptVariant;\n}\nexport interface UserQueryOptions {\n    footerVariant?: \"standard\";\n    replyButtonText?: string;\n    replyButtonIcon?: \"magnifyingGlass\" | \"send\" | \"thinMagnifyingGlass\" | \"ai-search\";\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}\ntype PageVariantBase = {\n    variantId: string;\n    widgetMounting: WidgetMounting[];\n    variantTests: PageVariantTest[];\n};\ntype PLPPageVariant = PageVariantBase & {\n    variantType: \"plp\";\n    plpIdExtractor: IdExtractor;\n};\ntype PDPPageVariant = PageVariantBase & {\n    variantType: \"pdp\";\n    parentProductIdExtractor?: IdExtractor;\n    productIdExtractor: IdExtractor;\n};\ntype VisitPageVariant = PageVariantBase & {\n    variantType: \"page_visit\";\n};\ntype OtherPageVariant = PageVariantBase & {\n    variantType: \"other\";\n};\ntype HomePageVariant = PageVariantBase & {\n    variantType: \"homepage\";\n};\ntype SearchPageVariant = PageVariantBase & {\n    variantType: \"search\";\n};\nexport type PageVariantConfig = PLPPageVariant | PDPPageVariant | VisitPageVariant | OtherPageVariant | HomePageVariant | SearchPageVariant;\nexport type OrgPageConfig = {\n    pageVariants: PageVariantConfig[];\n    widgetConfigs: Record<string, WidgetConfig>;\n    mountingConfigs: Record<string, WidgetMountingConfig>;\n};\ninterface OrgConfigContextType {\n    orgUIConfig: OrgUIConfig;\n}\nexport type OrgConfig = OrgUIConfig;\nexport { CategoryExtractorType, ColorNames, colorVar, PageVariantTestType, WidgetType, };\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}\nexport type { CategoryExtractor, ChatMessageVariant, ChatMessageConfig, ChatPreviewConfig, ChatPreviewIsLoadingWidgetConfig, ChatPreviewPostInteractionWidgetConfig, ChatPreviewProductComparisonWidgetConfig, ChatPreviewSuggestionButtonConfig, SocialProofV2WidgetConfig, ChatPreviewHeaderV2Config, ChatPreviewV2WidgetConfig, ChatPreviewFooterConfig, ChatPreviewHeaderConfig, ChatPreviewWidgetConfig, ChatPreviewVariant, ColorMapping, CustomerServiceIntegration, FloatingEntryPointConfig, FullCustomerServiceIntegration, IdExtractor, ImageBannerWidgetConfig, ImagePromptWidgetConfig, InsertionPoint, MultiImageConfig, OrgConfigContextType, OrgUIConfig, PageCardConfig, PageCardVariant, PageCardHoverVariant, PageCardIconVariant, ProductCardConfig, ProductCardVariant, ProductCardLayoutVariant, ProductCardHoverVariant, ProductLinkHoverVariant, ProductLinkIconVariant, ProductLinkVariant, ProductReviewConfig, ProductReviewStyleVariant, ProductReviewColorVariant, SearchPromptVariant, SearchPromptWidgetConfig, SearchResultsEntryPointWidgetConfig, ShowFloatingButtonOptions, SingleImagePromptWidgetConfig, SearchEntryPointWidgetConfig, SearchOverlayHostWidgetConfig, SocialProofConfig, SuggestionBarWidgetV2Config, SuggestionButtonConfig, SuggestionButtonVariant, URLTest, UserQueryButtonConfig, UserQueryButtonIcon, WelcomeSectionConfig, WelcomeSectionVariant, WelcomeSectionColorVariant, WidgetConfig, WrappingElement, SearchCardVariant, WidgetDisplayTests, NoOpWidgetConfig, WidgetMounting, StaticWidgetMounting, DynamicWidgetMounting, PDPPageVariant, PLPPageVariant, VisitPageVariant, OtherPageVariant, HomePageVariant, SearchPageVariant, NumRows, };\n","import { PageVariantConfig, WidgetMountingConfig, WidgetConfig, OrgUIConfig } from 'src/contexts/types';\nexport interface FrontendConfig {\n    merchantOverrideCss?: string;\n    pageVariants?: PageVariantConfig[];\n    mountingConfigs?: Record<string, WidgetMountingConfig>;\n    widgetConfigs?: Record<string, WidgetConfig>;\n    uiConfigs?: Omit<OrgUIConfig, 'merchantOverrideCss'>;\n}\n","import { OrganizationStatusEnum } from \"@spiffy-ai/commerce-api-client\";\nimport { OrganizationConfig } from \"src/application/models/api/organizationConfig\";\nimport { ColorMapping } from \"src/application/models/colorsConfig\";\nimport { FrontendConfig } from \"src/application/models/frontendConfig\";\nexport interface OrgConfigExperiment {\n    group?: string;\n    groupName?: string;\n    name?: string;\n    ruleId?: string;\n    value?: Record<string, unknown>;\n}\nexport interface OrgConfigFeatureGate {\n    groupName?: string;\n    name?: string;\n    ruleId?: string;\n    value?: boolean;\n}\nexport interface Organization {\n    id: string;\n    displayName: string;\n    domain: string;\n    shortName: string;\n    status: OrganizationStatusEnum;\n    createdAt?: string;\n    updatedAt?: string;\n}\nexport interface OrganizationSettings {\n    org: Organization;\n    settings: Record<string, unknown>;\n}\nexport interface OrgConfig {\n    configs: OrganizationConfig[];\n    experiments: OrgConfigExperiment[];\n    gates: OrgConfigFeatureGate[];\n    org: OrganizationSettings;\n    colorsConfig?: ColorMapping;\n    frontendConfig?: FrontendConfig;\n}\n"],"mappings":"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"}