@envive-ai/react-hooks 0.1.5 → 0.1.7

package/dist/models-ZpQcRZQK.cjs

@@ -0,0 +1,1536 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_types = require('./types-BwNrLPSZ.cjs');
+const require_logger = require('./logger-CSL2jqI9.cjs');
+const require_api = require('./api-DSFlctlc.cjs');
+let __spiffy_ai_commerce_api_client = require("@spiffy-ai/commerce-api-client");
+__spiffy_ai_commerce_api_client = require_chunk.__toESM(__spiffy_ai_commerce_api_client);
+
+//#region src/application/models/chatElementDisplayLocation.ts
+let ChatElementDisplayLocation = /* @__PURE__ */ function(ChatElementDisplayLocation$1) {
+	ChatElementDisplayLocation$1["IN_CHAT"] = "in_chat";
+	ChatElementDisplayLocation$1["CHAT_PREVIEW"] = "chat_preview";
+	ChatElementDisplayLocation$1["FLOATING_BUTTON"] = "floating_button";
+	ChatElementDisplayLocation$1["HELP_ME_CHOOSE"] = "help_me_choose";
+	ChatElementDisplayLocation$1["PLP_IMAGE_BANNER"] = "plp_image_banner";
+	ChatElementDisplayLocation$1["TOP_REVIEWS_SNIPPET"] = "top_reviews_snippet";
+	ChatElementDisplayLocation$1["BOTTOM_REVIEWS_SNIPPET"] = "bottom_reviews_snippet";
+	ChatElementDisplayLocation$1["BLOCK_BACK_BUTTON"] = "block_back_button";
+	ChatElementDisplayLocation$1["SWITCH_TO_AGENT"] = "switch_to_agent";
+	ChatElementDisplayLocation$1["CONVERSATIONAL_SEARCH"] = "conversational_search";
+	ChatElementDisplayLocation$1["GLOBAL_SEARCH_ENTRYPOINT"] = "global_search_entrypoint";
+	ChatElementDisplayLocation$1["SEARCH_NAV_ENTRYPOINT"] = "search_nav_entrypoint";
+	ChatElementDisplayLocation$1["SEARCH_PROMPT"] = "search_prompt";
+	ChatElementDisplayLocation$1["SEARCH_PROMPT_BUTTON"] = "search_prompt_button";
+	ChatElementDisplayLocation$1["PRODUCT_GRID"] = "product_grid";
+	ChatElementDisplayLocation$1["UNSPECIFIED"] = "unspecified";
+	ChatElementDisplayLocation$1["FILTER_MODAL"] = "filter_modal";
+	ChatElementDisplayLocation$1["PROMPT_CARD"] = "prompt_card";
+	ChatElementDisplayLocation$1["WINDOW_API_CALL"] = "window_api_call";
+	return ChatElementDisplayLocation$1;
+}({});
+
+//#endregion
+//#region src/application/models/events.ts
+let SpiffyEventName = /* @__PURE__ */ function(SpiffyEventName$1) {
+	SpiffyEventName$1["WidgetOpen"] = "spiffy:widgetopen";
+	SpiffyEventName$1["WidgetClose"] = "spiffy:widgetclose";
+	return SpiffyEventName$1;
+}({});
+
+//#endregion
+//#region src/application/models/googleAnalyticsEvents.ts
+var GoogleAnalyticsEvents = /* @__PURE__ */ function(GoogleAnalyticsEvents$1) {
+	GoogleAnalyticsEvents$1["ADD_TO_CART_v1"] = "add_to_cart";
+	GoogleAnalyticsEvents$1["ADD_TO_CART_v2"] = "addToCart";
+	return GoogleAnalyticsEvents$1;
+}(GoogleAnalyticsEvents || {});
+
+//#endregion
+//#region src/application/models/message.ts
+let MessageRole = /* @__PURE__ */ function(MessageRole$1) {
+	MessageRole$1["User"] = "user";
+	MessageRole$1["Assistant"] = "assistant";
+	return MessageRole$1;
+}({});
+let MessageType = /* @__PURE__ */ function(MessageType$1) {
+	MessageType$1["Text"] = "text";
+	MessageType$1["SuggestionClicked"] = "suggestion_clicked";
+	MessageType$1["Product"] = "product";
+	MessageType$1["ProductSearch"] = "product_search";
+	MessageType$1["Review"] = "review";
+	MessageType$1["QueryTyped"] = "query_typed";
+	MessageType$1["Separator"] = "separator";
+	MessageType$1["Page"] = "page";
+	MessageType$1["Search"] = "search";
+	MessageType$1["Attachment"] = "attachment";
+	MessageType$1["CXAgentResponse"] = "cx_agent_response";
+	MessageType$1["Form"] = "form";
+	MessageType$1["Order"] = "order";
+	MessageType$1["ProductSearchFilter"] = "product_search_filter";
+	return MessageType$1;
+}({});
+
+//#endregion
+//#region src/application/models/orgsEnum.ts
+const OrgShortName = {
+	Coterie: "coterie",
+	ForLoveAndLemons: "for-love-and-lemons",
+	Greenpan: "greenpan",
+	JordanCraig: "jordan-craig",
+	LarryAndSerges: "larry_and_serges",
+	LeapsAndRebounds: "leaps-and-rebounds",
+	MantraBrand: "mantra-brand",
+	Spanx: "spanx",
+	SpanxStaging: "staging-spanx",
+	Supergoop: "supergoop",
+	UniqueVintage: "unique-vintage",
+	JackArcher: "jack-archer",
+	SkinPerfection: "skin-perfection",
+	LookOptic: "look-optic",
+	FiveCbd: "five-cbd",
+	SnapSupplements: "snap-supplements",
+	Longevityrx: "longevityrx",
+	VenaCbd: "vena-cbd",
+	Medterra: "medterra",
+	Modells: "modells",
+	PressedFloral: "pressed-floral",
+	KindredBravely: "kindred-bravely",
+	WineEnthusiast: "wine-enthusiast",
+	HomegrownCannabis: "homegrown-cannabis",
+	DreamlandBaby: "dreamland-baby",
+	Bandolier: "bandolier",
+	WestonJonBoucher: "weston-jon-boucher",
+	KutFromTheKloth: "kut-from-the-kloth",
+	GrooveLife: "groove-life",
+	Carpe: "carpe",
+	WolfTactical: "wolf-tactical",
+	WolfMattress: "wolfmattress",
+	Default: "default"
+};
+
+//#endregion
+//#region src/application/models/productExperiment.ts
+let ProductExperiment = /* @__PURE__ */ function(ProductExperiment$1) {
+	ProductExperiment$1["Default"] = "default";
+	return ProductExperiment$1;
+}({});
+
+//#endregion
+//#region src/application/models/spiffyWidgets.ts
+/**
+* Enum of all widget names. These are widgets that are rendered and integrated into
+* a merchant's website.
+*/
+let SpiffyWidgets = /* @__PURE__ */ function(SpiffyWidgets$1) {
+	SpiffyWidgets$1["ImageBanner"] = "image_banner";
+	SpiffyWidgets$1["ImagePromptCard"] = "image_prompt_card";
+	SpiffyWidgets$1["SingleImagePrompt"] = "single_image_prompt";
+	SpiffyWidgets$1["EmbeddedWidget"] = "embedded_widget";
+	SpiffyWidgets$1["FloatingButton"] = "floating_button";
+	SpiffyWidgets$1["SuggestionBar"] = "suggestion_bar";
+	SpiffyWidgets$1["SearchPrompt"] = "search_prompt";
+	SpiffyWidgets$1["GlobalSearch"] = "global_search";
+	SpiffyWidgets$1["SearchResults"] = "search_results";
+	SpiffyWidgets$1["GlobalSearchEntryPoint"] = "global_search_entry_point";
+	return SpiffyWidgets$1;
+}({});
+
+//#endregion
+//#region src/application/models/graphql/queries/getMerchantOrgIdQuery.ts
+const getMerchantOrgIdQuery = `
+  query {
+    me {
+      org {
+        id
+      }
+    }
+  }
+`;
+
+//#endregion
+//#region src/application/models/guards/isBaseEcommerceEvent.ts
+/**
+* Checks if an event is a base Google Analytics ecommerce event.
+*
+* @param data The event to check.
+*
+* @returns True if the event is a base ecommerce event, false otherwise.
+*/
+const isBaseEcommerceEvent = (data) => data != null && typeof data === "object" && "ecommerce" in data && data.ecommerce != null && typeof data.ecommerce === "object" && "event" in data && typeof data.event === "string";
+
+//#endregion
+//#region src/application/models/guards/isGA4EcommerceEvent.ts
+/**
+* Checks if an event is a Google Analytics 4 ecommerce event.
+*
+* @param data The event to check.
+*
+* @returns True if the event is a GA4 ecommerce event, false otherwise.
+*/
+const isGA4EcommerceEvent = (data) => typeof data === "object" && data != null && "ecommerce" in data && data.ecommerce != null && typeof data.ecommerce === "object" && "items" in data.ecommerce && Array.isArray(data.ecommerce.items);
+
+//#endregion
+//#region src/application/models/guards/isLegacyUAEcommerceEvent.ts
+/**
+* Checks if an event is a legacy Universal Analytics ecommerce event.
+*
+* @param data The event to check.
+*
+* @returns True if the event is a legacy UA ecommerce event, false otherwise.
+*/
+const isLegacyUAEcommerceEvent = (data) => data != null && typeof data === "object" && "ecommerce" in data && data.ecommerce != null && typeof data.ecommerce === "object" && "add" in data.ecommerce && typeof data.ecommerce.add === "object";
+
+//#endregion
+//#region src/application/models/guards/isMobilePLPChatPlacementParameter.ts
+const isMobilePLPChatPlacementParameter = (value) => value != null && typeof value === "object" && "row_index" in value && typeof value.row_index === "number";
+
+//#endregion
+//#region src/application/models/guards/isSpanxTakeAQuizCtaParameter.ts
+const isSpanxTakeAQuizCtaParameter = (value) => value != null && typeof value === "object" && "text" in value && typeof value.text === "string";
+
+//#endregion
+//#region src/application/models/guards/isVariantInfo.ts
+const isPDPVariantInfo = (variantInfo) => "variant" in variantInfo && variantInfo.variant === "pdp" && "productId" in variantInfo && typeof variantInfo.productId === "string";
+const isPLPVariantInfo = (variantInfo) => "variant" in variantInfo && variantInfo.variant === "plp" && "plpId" in variantInfo && typeof variantInfo.plpId === "string";
+const isPageVisitVariantInfo = (variantInfo) => "variant" in variantInfo && variantInfo.variant === "page_visit" && "url" in variantInfo && typeof variantInfo.url === "string" && "pageVisitCategory" in variantInfo && Object.values(__spiffy_ai_commerce_api_client.PageVisitCategory).includes(variantInfo.pageVisitCategory);
+/**
+* Type guard to check if an object is a valid VariantInfo.
+*
+* @param variantInfo - The unknown object to check.
+*
+* @returns True if the data is a valid VariantInfo object, false otherwise.
+*/
+const isVariantInfo = (variantInfo) => variantInfo != null && typeof variantInfo === "object" && "variantId" in variantInfo && (isPDPVariantInfo(variantInfo) || isPLPVariantInfo(variantInfo) || isPageVisitVariantInfo(variantInfo));
+
+//#endregion
+//#region src/application/models/guards/api/isApiFormResponse.ts
+/**
+* Type guard to check if the provided data has the all of the properties (with the correct types) of
+* a FormResponseAttribute
+*
+* @param data - The data to check
+*
+* @returns true if the data has the correct properties, false otherwise
+*/
+const isApiFormResponseAttributes = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logError("isApiFormResponseAttributes: data is null or not an object", void 0, { data });
+		return false;
+	}
+	if ("form_category" in data && typeof data.form_category !== "object") {
+		require_logger.logger_default.logError("isApiFormResponseAttributes: form_category is not an object", void 0, { data });
+		return false;
+	}
+	if ("form_category" in data && typeof data.form_category === "object") {
+		if (!require_api.hasPropertyOfType(data.form_category, "form_type", "string") || !Object.values(__spiffy_ai_commerce_api_client.FormType).includes(data.form_category.form_type)) {
+			require_logger.logger_default.logError("isApiFormResponseAttributes: form_type is missing or not a valid form type", void 0, { data });
+			return false;
+		}
+	}
+	if (!require_api.hasPropertyOfType(data, "schema", "object")) {
+		require_logger.logger_default.logError("isApiFormResponseAttributes: schema is missing or not an object", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data.schema, "properties", "object")) {
+		require_logger.logger_default.logError("isApiFormResponseAttributes: schema.properties is missing or not an object", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data.schema, "required", "array")) {
+		require_logger.logger_default.logError("isApiFormResponseAttributes: schema.required is missing or not an array", void 0, { data });
+		return false;
+	}
+	if (!data.schema.required.every((key) => typeof key === "string" && key in data.schema.properties)) {
+		require_logger.logger_default.logError("isApiFormResponseAttributes: schema.required contains invalid property keys", void 0, { data });
+		return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiFormSubmittedResponseAttributes.ts
+const isApiFormSubmittedResponseAttributes = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logError("isApiFormSubmittedResponseAttributes", "data is null or not an object", data);
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "filled_schema", "object")) {
+		require_logger.logger_default.logError("isApiFormSubmittedResponseAttributes", "filled_schema is not an object", data);
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "form_response_id", "string")) {
+		require_logger.logger_default.logError("isApiFormSubmittedResponseAttributes", "form_response_id is not a string", data);
+		return false;
+	}
+	if (!("form_type" in data) || !Object.values(__spiffy_ai_commerce_api_client.FormType).includes(data.form_type)) {
+		require_logger.logger_default.logError("isApiFormSubmittedResponseAttributes", "form_type is not a valid form type enum", data);
+		return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiOrderResponseAttributes.ts
+const isApiOrderItemInfo = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logError("OrderItemInfo must be an object", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "order_item_id", "string")) {
+		require_logger.logger_default.logError("OrderItemInfo must have an order_item_id property", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "item_title", "string")) {
+		require_logger.logger_default.logError("OrderItemInfo must have an item_title property", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "item_price", "number")) {
+		require_logger.logger_default.logError("OrderItemInfo must have an item_price property", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "item_quantity", "number")) {
+		require_logger.logger_default.logError("OrderItemInfo must have an item_quantity property", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "image", "string", true)) {
+		require_logger.logger_default.logError("OrderItemInfo.image must be a string or null", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "fulfillment_display_status", "string", true)) {
+		require_logger.logger_default.logError("OrderItemInfo.fulfillment_display_status must be a string or null", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "tracking_url", "string", true)) {
+		require_logger.logger_default.logError("OrderItemInfo.tracking_url must be a string or null", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "delivered_at", "string", true)) {
+		require_logger.logger_default.logError("OrderItemInfo.delivered_at must be a string or null", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "estimated_delivery_at", "string", true)) {
+		require_logger.logger_default.logError("OrderItemInfo.estimated_delivery_at must be a string or null", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "in_transit_at", "string", true)) {
+		require_logger.logger_default.logError("OrderItemInfo.in_transit_at must be a string or null", void 0, { data });
+		return false;
+	}
+	return true;
+};
+const isApiOrderResponseAttributes = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logError("Order response attributes must be an object", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "created_at", "string")) {
+		require_logger.logger_default.logError("Order response attributes must have a created_at property and have type string", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "latest_event_date", "string")) {
+		require_logger.logger_default.logError("Order response attributes must have a latest_event_date property and have type string", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "line_items", "array") || !data.line_items.every((item) => isApiOrderItemInfo(item))) {
+		require_logger.logger_default.logError("Order response attributes must have a line_items property with at least one order item", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "order_id", "string")) {
+		require_logger.logger_default.logError("Order response attributes must have an order_id property and have type string", void 0, { data });
+		return false;
+	}
+	if (!require_api.hasPropertyOfType(data, "order_number", "string")) {
+		require_logger.logger_default.logError("Order response attributes must have an order_number property and have type string", void 0, { data });
+		return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiOrganizationConfig.ts
+const isApiOrgAnalyticsConfigAmplitude = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: data is not an object", data);
+		return false;
+	}
+	if (!("session_replay_enabled" in data) || typeof data.session_replay_enabled !== "boolean") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: session_replay_enabled is not a boolean", data);
+		return false;
+	}
+	if (!("session_replay_sample_rate" in data) || typeof data.session_replay_sample_rate !== "number") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: session_replay_sample_rate is not a number", data);
+		return false;
+	}
+	if (!("tracking_enabled" in data) || typeof data.tracking_enabled !== "boolean") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: tracking_enabled is not a boolean", data);
+		return false;
+	}
+	return true;
+};
+const isApiOrgAnalyticsConfigCustomerService = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigCustomerService: data is not an object", data);
+		return false;
+	}
+	if (!("provider" in data) || typeof data.provider !== "string") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigCustomerService: provider is not a string", data);
+		return false;
+	}
+	return true;
+};
+const isApiOrgAnalyticsConfigGoogleAnalytics = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigGoogleAnalytics: data is not an object", data);
+		return false;
+	}
+	if (!("measurement_id" in data) || typeof data.measurement_id !== "string") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgAnalyticsConfigGoogleAnalytics: measurement_id is not a string", data);
+		return false;
+	}
+	return true;
+};
+/**
+*
+* @param data
+* @returns
+*/
+const isApiOrgAnalyticsConfig = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgAnalyticsConfig: data is not an object", data);
+		return false;
+	}
+	if ("amplitude" in data && !isApiOrgAnalyticsConfigAmplitude(data.amplitude)) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgAnalyticsConfig: amplitude is not an object", data);
+		return false;
+	}
+	if ("customer_service" in data && !isApiOrgAnalyticsConfigCustomerService(data.customer_service)) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgAnalyticsConfig: customer_service is not an object", data);
+		return false;
+	}
+	if ("google_analytics" in data && !isApiOrgAnalyticsConfigGoogleAnalytics(data.google_analytics)) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgAnalyticsConfig: google_analytics is not an object", data);
+		return false;
+	}
+	return true;
+};
+/**
+*
+* @param data
+* @returns
+*/
+const isApiOrganizationConfig = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgConfig: data is not an object", data);
+		return false;
+	}
+	if (!("created_at" in data)) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgConfig: created_at is not defined", data);
+		return false;
+	}
+	if (!("namespace" in data) || typeof data.namespace !== "string") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgConfig: namespace is not a string", data);
+		return false;
+	}
+	if (!("is_latest" in data) || typeof data.is_latest !== "boolean") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgConfig: is_latest is not a boolean", data);
+		return false;
+	}
+	if (!("version" in data) || typeof data.version !== "string") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgConfig: version is not a string", data);
+		return false;
+	}
+	if (!("updated_at" in data)) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgConfig: updated_at is not defined", data);
+		return false;
+	}
+	if (!("config" in data) || typeof data.config !== "object" || !isApiOrgAnalyticsConfig(data.config)) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgConfig: config is not an object", data);
+		return false;
+	}
+	if ("organization_id" in data && typeof data.organization_id !== "string") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgConfig: organization_id is not a string", data);
+		return false;
+	}
+	if ("id" in data && typeof data.id !== "string") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isOrgConfig: id is not a string", data);
+		return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiOrgConfigResults.ts
+const isApiOrgConfigExperiment = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigExperiment: data is not an object", void 0, { data });
+		return false;
+	}
+	if ("group" in data && typeof data.group !== "string" && data.group !== void 0) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigExperiment: group is not a string or undefined", void 0, { data });
+		return false;
+	}
+	if ("group_name" in data && typeof data.group_name !== "string" && data.group_name !== void 0) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigExperiment: group_name is not a string", void 0, { data });
+		return false;
+	}
+	if ("name" in data && typeof data.name !== "string" && data.name !== void 0) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigExperiment: name is not a string", void 0, { data });
+		return false;
+	}
+	if ("rule_id" in data && typeof data.rule_id !== "string" && data.rule_id !== void 0) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigExperiment: rule_id is not a string", void 0, { data });
+		return false;
+	}
+	if ("value" in data && typeof data.value !== "object" && data.value !== void 0) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigExperiment: value is not an object", void 0, { data });
+		return false;
+	}
+	return true;
+};
+const isApiOrgConfigFeatureGate = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigFeatureGate: data is not an object", void 0, { data });
+		return false;
+	}
+	if ("name" in data && typeof data.name !== "string" && data.name !== void 0) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigFeatureGate: name is not a string", void 0, { data });
+		return false;
+	}
+	if ("rule_id" in data && typeof data.rule_id !== "string" && data.rule_id !== void 0) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigFeatureGate: rule_id is not a string", void 0, { data });
+		return false;
+	}
+	if ("value" in data && typeof data.value !== "boolean" && data.value !== void 0) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigFeatureGate: value is not a boolean", void 0, { data });
+		return false;
+	}
+	return true;
+};
+const isApiOrganization = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrganization: data is not an object", void 0, { data });
+		return false;
+	}
+	if (!("id" in data) || typeof data.id !== "string") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrganization: id is not a string", void 0, { data });
+		return false;
+	}
+	if (!("display_name" in data) || typeof data.display_name !== "string") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrganization: display_name is not a string", void 0, { data });
+		return false;
+	}
+	if (!("domain" in data) || typeof data.domain !== "string") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrganization: domain is not a string", void 0, { data });
+		return false;
+	}
+	if (!("short_name" in data) || typeof data.short_name !== "string") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrganization: short_name is not a string", void 0, { data });
+		return false;
+	}
+	if (!("status" in data) || !Object.values(__spiffy_ai_commerce_api_client.OrganizationStatusEnum).includes(data.status)) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrganization: status is not a valid OrganizationStatusEnum value", void 0, { data });
+		return false;
+	}
+	if ("created_at" in data && !(data.created_at instanceof Date) && typeof data.created_at !== "string" && data.created_at !== void 0) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrganization: created_at is not a Date", void 0, { data });
+		return false;
+	}
+	if ("updated_at" in data && !(data.updated_at instanceof Date) && typeof data.updated_at !== "string" && data.updated_at !== void 0) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrganization: updated_at is not a Date", void 0, { data });
+		return false;
+	}
+	return true;
+};
+const isApiOrgConfigOrganizationSettings = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigOrganizationSettings: data is not an object", void 0, { data });
+		return false;
+	}
+	if (!("org" in data) || !isApiOrganization(data.org)) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigOrganizationSettings: org is not an object", void 0, { data });
+		return false;
+	}
+	return true;
+};
+/**
+*
+* @param data
+* @returns
+*/
+const isApiOrgConfigResults = (data) => {
+	if (data == null || typeof data !== "object") {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigResults: data is not an object", void 0, { data });
+		return false;
+	}
+	if (!("configs" in data) || !Array.isArray(data.configs) || !data.configs.every((config) => isApiOrganizationConfig(config))) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigResults: configs is not an array", void 0, { data });
+		return false;
+	}
+	if ("experiments" in data && data.experiments !== void 0 && (!Array.isArray(data.experiments) || !data.experiments.every((exp) => isApiOrgConfigExperiment(exp)))) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigResults: experiments is not an array or contains invalid items", void 0, { data });
+		return false;
+	}
+	if (!("gates" in data) || !Array.isArray(data.gates) || !data.gates.every((gate) => isApiOrgConfigFeatureGate(gate))) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigResults: gates is not an array or contains invalid items", void 0, { data });
+		return false;
+	}
+	if (!("org" in data) || !isApiOrgConfigOrganizationSettings(data.org)) {
+		require_logger.logger_default.logDebug("[spiffy-ai] isApiOrgConfigResults: org is not an object or has invalid fields", void 0, { data });
+		return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiPageResponseAttributes.ts
+const isApiPageResponseAttributes = (obj) => {
+	if (obj == null || typeof obj !== "object") return false;
+	if ("title" in obj && obj.title != null && typeof obj.title !== "string") return false;
+	if ("description" in obj && typeof obj.description !== "string") return false;
+	if ("url" in obj && typeof obj.url !== "string") return false;
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiPLPEventAttributes.ts
+const isApiPLPIdAttribute = (data) => {
+	if (data == null || typeof data !== "object") return false;
+	if (!("id" in data) || typeof data.id !== "string") return false;
+	return true;
+};
+const isApiPLPEventAttributes = (data) => {
+	if (data == null || typeof data !== "object") return false;
+	if (!("category" in data) || typeof data.category !== "string" || !Object.values(__spiffy_ai_commerce_api_client.PLPAttributeCategory).includes(data.category)) return false;
+	if (!("attributes" in data) || typeof data.attributes !== "object" || !isApiPLPIdAttribute(data.attributes)) return false;
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/api/isApiProductSearchFilterAttributes.ts
+const isApiProductSearchFilterResponseAttributes = (attributes) => {
+	if (attributes == null || typeof attributes !== "object") return false;
+	if ("filter_name" in attributes && typeof attributes.filter_name !== "string") return false;
+	return true;
+};
+
+//#endregion
+//#region src/application/models/guards/graphQL/isGraphQLColorsConfig.ts
+const REQUIRED_COLOR_FIELDS = [
+	"accent_primary",
+	"accent_secondary",
+	"background_dark",
+	"background_light",
+	"background_primary",
+	"background_saturated",
+	"background_secondary",
+	"background_secondary_dark",
+	"background_tertiary",
+	"border_dark",
+	"border_light",
+	"border_medium",
+	"border_outline",
+	"text_accent",
+	"text_light",
+	"text_link",
+	"text_primary",
+	"text_secondary"
+];
+const isGraphQLColorsConfig = (data) => {
+	if (typeof data !== "object" || data === null) {
+		require_logger.logger_default.logError("Invalid graphql response for colors config", void 0, { data });
+		return false;
+	}
+	const missingFields = REQUIRED_COLOR_FIELDS.filter((field) => !(field in data) || typeof data[field] !== "string");
+	if (missingFields.length === REQUIRED_COLOR_FIELDS.length) {
+		require_logger.logger_default.logError("All color fields are missing or null", void 0);
+		return false;
+	}
+	if (missingFields.length > 0) {
+		require_logger.logger_default.logError("Missing or invalid color fields", void 0, {
+			data,
+			missingFields
+		});
+		return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/application/models/utils/snakeToCamelTransformer.ts
+/**
+* Generic utility to transform snake_case object keys to camelCase at runtime.
+* This is the runtime equivalent of the CamelCasedPropertiesDeep type utility.
+*/
+const PRESERVED_ACRONYMS = [
+	"PLP",
+	"PDP",
+	"SVG"
+];
+/**
+* Converts a snake_case string to camelCase
+* Handles specific acronyms like PLP and PDP correctly
+*/
+const toCamelCase = (str) => {
+	let processedStr = str;
+	for (const acronym of PRESERVED_ACRONYMS) {
+		const regex = new RegExp(`_${acronym}_?`, "gi");
+		if (processedStr.match(regex)) processedStr = processedStr.replace(regex, (v) => v.endsWith("_") ? `${acronym}_` : `${acronym}`);
+	}
+	return processedStr.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+};
+/**
+* Converts a camelCase string to snake_case
+* Handles consecutive capital letters correctly (e.g., "PDP" -> "pdp", not "p_d_p")
+* Preserves specific acronyms like PLP and PDP as lowercase in snake_case
+*/
+const toSnakeCase = (str) => str.replace(/([A-Z])(?=[a-z])/g, "_$1").replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase().replace(/^_/, "");
+/**
+* Recursively transforms all object keys from snake_case to camelCase
+*/
+const transformSnakeToCamel = (obj) => {
+	if (obj === null || obj === void 0) return obj;
+	if (Array.isArray(obj)) return obj.map((val) => transformSnakeToCamel(val));
+	if (typeof obj === "object") {
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) {
+			const camelKey = toCamelCase(key);
+			result[camelKey] = transformSnakeToCamel(value);
+		}
+		return result;
+	}
+	return obj;
+};
+/**
+* Recursively transforms all object keys from camelCase to snake_case
+*/
+const transformCamelToSnake = (obj) => {
+	if (obj === null || obj === void 0) return obj;
+	if (Array.isArray(obj)) return obj.map(transformCamelToSnake);
+	if (typeof obj === "object") {
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) {
+			const snakeKey = toSnakeCase(key);
+			result[snakeKey] = transformCamelToSnake(value);
+		}
+		return result;
+	}
+	return obj;
+};
+
+//#endregion
+//#region src/application/models/utils/stringToFulfillmentDisplayStatusEnumValue.ts
+/**
+* Converts a string to a FulfillmentDisplayStatus enum value.
+*
+* @param status - The string to convert.
+*
+* @returns The FulfillmentDisplayStatus enum value or undefined if the string
+* does not map to a valid enum
+*/
+const stringToFulfillmentDisplayStatusEnumValue = (status) => {
+	switch (status) {
+		case "ATTEMPTED_DELIVERY": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.ATTEMPTED_DELIVERY;
+		case "CANCELED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.CANCELED;
+		case "CONFIRMED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.CONFIRMED;
+		case "DELIVERED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.DELIVERED;
+		case "FAILURE": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.FAILURE;
+		case "FULFILLED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.FULFILLED;
+		case "IN_TRANSIT": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.IN_TRANSIT;
+		case "LABEL_PRINTED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.LABEL_PRINTED;
+		case "LABEL_PURCHASED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.LABEL_PURCHASED;
+		case "LABEL_VOIDED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.LABEL_VOIDED;
+		case "MARKED_AS_FULFILLED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.MARKED_AS_FULFILLED;
+		case "NOT_DELIVERED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.NOT_DELIVERED;
+		case "OUT_FOR_DELIVERY": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.OUT_FOR_DELIVERY;
+		case "PICKED_UP": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.PICKED_UP;
+		case "READY_FOR_PICKUP": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.READY_FOR_PICKUP;
+		case "SUBMITTED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.SUBMITTED;
+		case "IN_PROGRESS": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.IN_PROGRESS;
+		case "ON_HOLD": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.ON_HOLD;
+		case "OPEN": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.OPEN;
+		case "PARTIALLY_FULFILLED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.PARTIALLY_FULFILLED;
+		case "PENDING_FULFILLMENT": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.PENDING_FULFILLMENT;
+		case "REQUEST_DECLINED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.REQUEST_DECLINED;
+		case "RESTOCKED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.RESTOCKED;
+		case "SCHEDULED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.SCHEDULED;
+		case "UNFULFILLED": return __spiffy_ai_commerce_api_client.FulfillmentDisplayStatus.UNFULFILLED;
+		default: return;
+	}
+};
+
+//#endregion
+//#region src/application/models/validators/validateGraphQLColorsConfig.ts
+const validateGraphQLColorsConfig = (data) => {
+	if (!isGraphQLColorsConfig(data)) return;
+};
+
+//#endregion
+//#region src/merchants/domInsertion.ts
+var DOMInsertionType = /* @__PURE__ */ function(DOMInsertionType$1) {
+	DOMInsertionType$1["AFTER"] = "after";
+	DOMInsertionType$1["BEFORE"] = "before";
+	DOMInsertionType$1["ADJACENT_AFTER_BEGIN"] = "adjacent-after-begin";
+	DOMInsertionType$1["ADJACENT_BEFORE_BEGIN"] = "adjacent-before-begin";
+	DOMInsertionType$1["ADJACENT_AFTER_END"] = "adjacent-after-end";
+	DOMInsertionType$1["ADJACENT_BEFORE_END"] = "adjacent-before-end";
+	DOMInsertionType$1["APPEND_CHILD"] = "append-child";
+	DOMInsertionType$1["NONE"] = "none";
+	return DOMInsertionType$1;
+}(DOMInsertionType || {});
+
+//#endregion
+//#region src/merchants/gridInsertion.ts
+var GridInsertionType = /* @__PURE__ */ function(GridInsertionType$1) {
+	GridInsertionType$1["FIXED_1"] = "fixed-1";
+	GridInsertionType$1["FIXED_2"] = "fixed-2";
+	GridInsertionType$1["FIXED_3"] = "fixed-3";
+	GridInsertionType$1["FIXED_4"] = "fixed-4";
+	GridInsertionType$1["FIXED_5"] = "fixed-5";
+	GridInsertionType$1["FIXED_6"] = "fixed-6";
+	GridInsertionType$1["FIXED_7"] = "fixed-7";
+	GridInsertionType$1["FIXED_8"] = "fixed-8";
+	GridInsertionType$1["FIXED_9"] = "fixed-9";
+	GridInsertionType$1["FIXED_12"] = "fixed-12";
+	GridInsertionType$1["FIXED_13"] = "fixed-13";
+	GridInsertionType$1["ROW_1"] = "row-1";
+	GridInsertionType$1["ROW_2"] = "row-2";
+	GridInsertionType$1["ROW_3"] = "row-3";
+	GridInsertionType$1["ROW_4"] = "row-4";
+	return GridInsertionType$1;
+}(GridInsertionType || {});
+
+//#endregion
+//#region src/application/models/validators/validateGraphQLFrontendConfig.ts
+const validateAndTransformPageVariants = (config) => {
+	const { variantChecks, widgetMounting,...rest } = transformSnakeToCamel(config);
+	const variantTests = Array.isArray(variantChecks) ? variantChecks.map(({ checkType,...restCheck }) => ({
+		...restCheck,
+		testType: checkType
+	})) : [];
+	const normalizedWidgetMounting = Array.isArray(widgetMounting) ? widgetMounting.map(({ mountingPointWidgets,...restMounting }) => ({
+		...restMounting,
+		...Array.isArray(mountingPointWidgets) ? { mountingPointWidgets: mountingPointWidgets.map(({ checks,...restWidget }) => ({
+			...restWidget,
+			tests: Array.isArray(checks) ? checks.map(({ checkType,...restCheck }) => ({
+				...restCheck,
+				testType: checkType
+			})) : []
+		})) } : {}
+	})) : [];
+	const normalizedConfig = {
+		...rest,
+		...variantTests ? { variantTests } : {},
+		...normalizedWidgetMounting ? { widgetMounting: normalizedWidgetMounting } : {}
+	};
+	const variantId = normalizedConfig.variantId;
+	const variantType = normalizedConfig.variantType;
+	if (typeof variantId !== "string" || !variantId) throw new Error(`Missing or invalid variantId for pageVariant`);
+	if (typeof variantType !== "string" || !variantType) throw new Error(`Missing or invalid variantType for pageVariant '${variantId}'`);
+	if (!Array.isArray(variantTests)) throw new Error(`Missing or invalid variantTests for pageVariant '${variantId}'. Must be an array`);
+	for (const test of variantTests) {
+		if (!test.testType || typeof test.testType !== "string") throw new Error(`Invalid variantTest.testType for pageVariant '${variantId}'`);
+		if (!Object.values(require_types.PageVariantTestType).includes(test.testType)) throw new Error(`Invalid testType '${test.testType}' for pageVariant '${variantId}'. Valid types: ${Object.values(require_types.PageVariantTestType).join(", ")}`);
+	}
+	if (!Array.isArray(normalizedWidgetMounting)) throw new Error(`Missing or invalid widgetMounting for pageVariant '${variantId}'. Must be an array`);
+	for (const mounting of normalizedWidgetMounting) {
+		if (typeof mounting.mountingConfigId !== "string" || !mounting.mountingConfigId) throw new Error(`Invalid mountingConfigId in widgetMounting for pageVariant '${variantId}'`);
+		if (mounting.widgetConfigId && typeof mounting.widgetConfigId !== "string") throw new Error(`Invalid widgetConfigId in widgetMounting for pageVariant '${variantId}'`);
+		if (mounting.mountingPointWidgets) for (const widget of mounting.mountingPointWidgets) {
+			if (typeof widget.widgetConfigId !== "string" || !widget.widgetConfigId) throw new Error(`Invalid widgetConfigId in mountingPointWidgets for pageVariant '${variantId}'`);
+			if (!Array.isArray(widget.tests)) throw new Error(`Invalid or missing tests in mountingPointWidgets for pageVariant '${variantId}'`);
+		}
+	}
+	if (variantType === "plp") {
+		if (typeof normalizedConfig.plpIdExtractor !== "string" || !normalizedConfig.plpIdExtractor) throw new Error(`Missing or invalid plpIdExtractor for PLP pageVariant '${variantId}'`);
+	}
+	if (variantType === "pdp") {
+		if (typeof normalizedConfig.productIdExtractor !== "string" || !normalizedConfig.productIdExtractor) throw new Error(`Missing or invalid productIdExtractor for PDP pageVariant '${variantId}'`);
+		if (normalizedConfig.parentProductIdExtractor && typeof normalizedConfig.parentProductIdExtractor !== "string") throw new Error(`Invalid parentProductIdExtractor for PDP pageVariant '${variantId}'. Must be string if provided`);
+	}
+	return normalizedConfig;
+};
+const validateAndTransformMountingConfig = (config, configKey) => {
+	const normalizedConfig = { ...config };
+	if (normalizedConfig.checkId && !normalizedConfig.testId) {
+		normalizedConfig.testId = normalizedConfig.checkId;
+		delete normalizedConfig.checkId;
+	}
+	if (typeof normalizedConfig.mountingConfigId !== "string" || !normalizedConfig.mountingConfigId) throw new Error(`Missing or invalid mountingConfigId for config '${configKey}'`);
+	if (typeof normalizedConfig.containerId !== "string" || !normalizedConfig.containerId) throw new Error(`Missing or invalid containerId for config '${configKey}'`);
+	if (typeof normalizedConfig.testId !== "string" || !normalizedConfig.testId) throw new Error(`Missing or invalid testId for config '${configKey}'`);
+	if (!normalizedConfig.insertionPoint || typeof normalizedConfig.insertionPoint !== "object" || Array.isArray(normalizedConfig.insertionPoint)) throw new Error(`Missing or invalid insertionPoint for config '${configKey}'`);
+	const insertionPoint = normalizedConfig.insertionPoint;
+	if (typeof insertionPoint.selector !== "string" || !insertionPoint.selector) throw new Error(`Missing or invalid insertionPoint.selector for config '${configKey}'`);
+	if (typeof insertionPoint.insertionType !== "string" || !insertionPoint.insertionType) throw new Error(`Missing or invalid insertionPoint.insertionType for config '${configKey}'`);
+	if (!Object.values(DOMInsertionType).includes(insertionPoint.insertionType)) throw new Error(`Invalid insertionPoint.insertionType '${insertionPoint.insertionType}' for config '${configKey}'. Valid types: ${Object.values(DOMInsertionType).join(", ")}`);
+	if (insertionPoint.selectionIndex != null && typeof insertionPoint.selectionIndex !== "number") throw new Error(`Invalid insertionPoint.selectionIndex for config '${configKey}'. Must be a number or null/undefined`);
+	let parentInsertionPoint;
+	if (normalizedConfig.parentInsertionPoint) {
+		if (typeof normalizedConfig.parentInsertionPoint !== "object" || Array.isArray(normalizedConfig.parentInsertionPoint)) throw new Error(`Invalid parentInsertionPoint for config '${configKey}'. Must be an object`);
+		const parentPoint = normalizedConfig.parentInsertionPoint;
+		if (typeof parentPoint.selector !== "string" || !parentPoint.selector) throw new Error(`Missing or invalid parentInsertionPoint.selector for config '${configKey}'`);
+		if (typeof parentPoint.insertionType !== "string" || !parentPoint.insertionType) throw new Error(`Missing or invalid parentInsertionPoint.insertionType for config '${configKey}'`);
+		if (!Object.values(DOMInsertionType).includes(parentPoint.insertionType)) throw new Error(`Invalid parentInsertionPoint.insertionType '${parentPoint.insertionType}' for config '${configKey}'. Valid types: ${Object.values(DOMInsertionType).join(", ")}`);
+		if (parentPoint.selectionIndex != null && typeof parentPoint.selectionIndex !== "number") throw new Error(`Invalid parentInsertionPoint.selectionIndex for config '${configKey}'. Must be a number or null/undefined`);
+		parentInsertionPoint = {
+			selector: parentPoint.selector,
+			insertionType: parentPoint.insertionType,
+			selectionIndex: parentPoint.selectionIndex
+		};
+	}
+	let wrappingElement;
+	if (normalizedConfig.wrappingElement) {
+		if (typeof normalizedConfig.wrappingElement !== "object" || Array.isArray(normalizedConfig.wrappingElement)) throw new Error(`Invalid wrappingElement for config '${configKey}'. Must be an object`);
+		const wrapping = normalizedConfig.wrappingElement;
+		if (typeof wrapping.className !== "string" || !wrapping.className) throw new Error(`Missing or invalid wrappingElement.className for config '${configKey}'`);
+		if (typeof wrapping.element !== "string" || !wrapping.element) throw new Error(`Missing or invalid wrappingElement.element for config '${configKey}'`);
+		if (typeof wrapping.insertionType !== "string" || !wrapping.insertionType) throw new Error(`Missing or invalid wrappingElement.insertionType for config '${configKey}'`);
+		if (!Object.values(DOMInsertionType).includes(wrapping.insertionType)) throw new Error(`Invalid wrappingElement.insertionType '${wrapping.insertionType}' for config '${configKey}'. Valid types: ${Object.values(DOMInsertionType).join(", ")}`);
+		wrappingElement = {
+			className: wrapping.className,
+			element: wrapping.element,
+			insertionType: wrapping.insertionType
+		};
+	}
+	if (normalizedConfig.divCheckSelector != null && typeof normalizedConfig.divCheckSelector !== "string") throw new Error(`Invalid divCheckSelector for config '${configKey}'. Must be a string or null/undefined`);
+	if (normalizedConfig.className != null && typeof normalizedConfig.className !== "string") throw new Error(`Invalid className for config '${configKey}'. Must be a string or null/undefined`);
+	if (normalizedConfig.suppressionSelector != null && typeof normalizedConfig.suppressionSelector !== "string") throw new Error(`Invalid suppressionSelector for config '${configKey}'. Must be a string or null/undefined`);
+	if (normalizedConfig.dataAttributes != null && (typeof normalizedConfig.dataAttributes !== "object" || Array.isArray(normalizedConfig.dataAttributes))) throw new Error(`Invalid dataAttributes for config '${configKey}'. Must be an object or null/undefined`);
+	if (normalizedConfig.style != null && (typeof normalizedConfig.style !== "object" || Array.isArray(normalizedConfig.style))) throw new Error(`Invalid style for config '${configKey}'. Must be an object or null/undefined`);
+	let gridInsertionType;
+	if (normalizedConfig.gridInsertionType) {
+		if (typeof normalizedConfig.gridInsertionType !== "string" || !normalizedConfig.gridInsertionType) throw new Error(`Invalid gridInsertionType for config '${configKey}'. Must be a string`);
+		if (!Object.values(GridInsertionType).includes(normalizedConfig.gridInsertionType)) throw new Error(`Invalid gridInsertionType '${normalizedConfig.gridInsertionType}' for config '${configKey}'. Valid types: ${Object.values(GridInsertionType).join(", ")}`);
+		gridInsertionType = normalizedConfig.gridInsertionType;
+	}
+	const result = {
+		mountingConfigId: normalizedConfig.mountingConfigId,
+		containerId: normalizedConfig.containerId,
+		testId: normalizedConfig.testId,
+		insertionPoint: {
+			selector: insertionPoint.selector,
+			insertionType: insertionPoint.insertionType,
+			...insertionPoint.selectionIndex != null && { selectionIndex: insertionPoint.selectionIndex }
+		}
+	};
+	if (parentInsertionPoint) result.parentInsertionPoint = parentInsertionPoint;
+	if (gridInsertionType) result.gridInsertionType = gridInsertionType;
+	if (wrappingElement) result.wrappingElement = wrappingElement;
+	if (normalizedConfig.divCheckSelector) result.divCheckSelector = normalizedConfig.divCheckSelector;
+	if (normalizedConfig.className) result.className = normalizedConfig.className;
+	if (normalizedConfig.suppressionSelector) result.suppressionSelector = normalizedConfig.suppressionSelector;
+	if (normalizedConfig.dataAttributes) result.dataAttributes = normalizedConfig.dataAttributes;
+	if (normalizedConfig.style) result.style = normalizedConfig.style;
+	return result;
+};
+const validateAndTransformWidgetConfig = (config, configKey) => {
+	const normalizedConfig = transformSnakeToCamel(config);
+	if (typeof normalizedConfig.widgetConfigId !== "string" || !normalizedConfig.widgetConfigId) throw new Error(`Missing or invalid widgetConfigId for widget config '${configKey}'`);
+	if (typeof normalizedConfig.type !== "string" || !normalizedConfig.type) throw new Error(`Missing or invalid type for widget config '${configKey}'`);
+	if (normalizedConfig.contentId != null && typeof normalizedConfig.contentId !== "string") throw new Error(`Invalid contentId for widget config '${configKey}'. Must be a string or null/undefined`);
+	return normalizedConfig;
+};
+const validateGraphQLFrontendConfig = (data) => {
+	if (data === null || data === void 0) return;
+	if (typeof data !== "object" || Array.isArray(data)) {
+		require_logger.logger_default.logWarn("Invalid GraphQL frontend config data: not an object", void 0, { data });
+		return;
+	}
+	const obj = data;
+	if ("merchant_override_css" in obj && typeof obj.merchant_override_css !== "string" && obj.merchant_override_css !== null) {
+		require_logger.logger_default.logWarn("Invalid GraphQL frontend config data: merchant_override_css must be a string or null", void 0, { data });
+		return;
+	}
+	if ("page_variants" in obj) {
+		if (obj.page_variants !== void 0 && obj.page_variants !== null && !Array.isArray(obj.page_variants)) {
+			require_logger.logger_default.logWarn("Invalid GraphQL frontend config data: page_variants must be an array or null/undefined", void 0, { data });
+			return;
+		}
+	}
+	if ("mounting_configs" in obj) {
+		if (obj.mounting_configs !== void 0 && obj.mounting_configs !== null && !Array.isArray(obj.mounting_configs)) {
+			require_logger.logger_default.logWarn("Invalid GraphQL frontend config data: mounting_configs must be an array or null/undefined", void 0, { data });
+			return;
+		}
+	}
+	if ("widget_configs" in obj) {
+		if (obj.widget_configs !== void 0 && obj.widget_configs !== null && !Array.isArray(obj.widget_configs)) {
+			require_logger.logger_default.logWarn("Invalid GraphQL frontend config data: widget_configs must be an array or null/undefined", void 0, { data });
+			return;
+		}
+	}
+	if ("ui_configs" in obj && typeof obj.ui_configs !== "object" && obj.ui_configs !== null) {
+		require_logger.logger_default.logWarn("Invalid GraphQL frontend config data: ui_configs must be an object or null/undefined", void 0, { data });
+		return;
+	}
+	try {
+		const transformedData = transformSnakeToCamel(obj);
+		if (transformedData.pageVariants && Array.isArray(transformedData.pageVariants)) {
+			const pageVariantsArray = transformedData.pageVariants;
+			const validatedPageVariants = [];
+			for (const variant of pageVariantsArray) if (variant && typeof variant === "object" && typeof variant.variantId === "string") try {
+				const validatedVariant = validateAndTransformPageVariants(variant);
+				validatedPageVariants.push(validatedVariant);
+			} catch (error) {
+				require_logger.logger_default.logWarn("Invalid page variant, skipping", error, {
+					variantId: variant.variantId,
+					variant
+				});
+			}
+			else require_logger.logger_default.logWarn("Invalid page variant structure, skipping", void 0, { variant });
+			transformedData.pageVariants = validatedPageVariants;
+		}
+		if (transformedData.mountingConfigs && Array.isArray(transformedData.mountingConfigs)) {
+			const mountingConfigsArray = transformedData.mountingConfigs;
+			const mountingConfigsRecord = {};
+			for (const item of mountingConfigsArray) if (item && typeof item.key === "string" && item.config && typeof item.config === "object") try {
+				const config = item.config;
+				const validatedConfig = validateAndTransformMountingConfig(config, item.key);
+				mountingConfigsRecord[item.key] = validatedConfig;
+			} catch (error) {
+				require_logger.logger_default.logWarn("Invalid mounting config, skipping", error, {
+					configKey: item.key,
+					config: item.config
+				});
+			}
+			else require_logger.logger_default.logWarn("Invalid mounting config item structure, skipping", void 0, { item });
+			transformedData.mountingConfigs = mountingConfigsRecord;
+		}
+		if (transformedData.widgetConfigs && Array.isArray(transformedData.widgetConfigs)) {
+			const widgetConfigsArray = transformedData.widgetConfigs;
+			const widgetConfigsRecord = {};
+			for (const item of widgetConfigsArray) if (item && typeof item.key === "string" && item.config && typeof item.config === "object") try {
+				const config = item.config;
+				const validatedConfig = validateAndTransformWidgetConfig(config, item.key);
+				widgetConfigsRecord[item.key] = validatedConfig;
+			} catch (error) {
+				require_logger.logger_default.logWarn("Invalid widget config, skipping", error, {
+					configKey: item.key,
+					config: item.config
+				});
+			}
+			else require_logger.logger_default.logWarn("Invalid widget config item structure, skipping", void 0, { item });
+			transformedData.widgetConfigs = widgetConfigsRecord;
+		}
+		return transformedData;
+	} catch (error) {
+		require_logger.logger_default.logWarn("Failed to validate and transform GraphQL frontend config data", error, { data });
+		return;
+	}
+};
+
+//#endregion
+//#region src/application/models/validators/validateGraphQLOrgId.ts
+const validateGraphQLOrgId = (data) => {
+	if (typeof data !== "string" || data === "") return;
+	return data;
+};
+
+//#endregion
+//#region src/application/models/validators/validateMobilePLPChatPlacementParameter.ts
+const validateMobilePLPChatPlacementParameter = (value) => {
+	if (!isMobilePLPChatPlacementParameter(value)) return;
+	return { rowIndex: value.row_index };
+};
+
+//#endregion
+//#region src/application/models/validators/validateOrganizationConfig.ts
+const validateOrganizationConfig = (data) => {
+	if (!isApiOrganizationConfig(data)) return;
+	return {
+		id: data.id,
+		createdAt: data.created_at.toISOString(),
+		namespace: data.namespace,
+		organizationId: data.organization_id,
+		isLatest: data.is_latest,
+		version: data.version,
+		updatedAt: data.updated_at.toISOString(),
+		config: {
+			amplitude: data.config.amplitude ? {
+				sessionReplayEnabled: data.config.amplitude.session_replay_enabled,
+				sessionReplaySampleRate: data.config.amplitude.session_replay_sample_rate,
+				trackingEnabled: data.config.amplitude.tracking_enabled
+			} : void 0,
+			customerService: data.config.customer_service ? { provider: data.config.customer_service.provider } : void 0,
+			googleAnalytics: data.config.google_analytics ? { measurementId: data.config.google_analytics.measurement_id } : void 0
+		}
+	};
+};
+
+//#endregion
+//#region src/application/models/validators/validateOrgConfigResults.ts
+/**
+*
+* @param data
+* @returns
+*/
+const validateOrgConfigResults = (data) => {
+	if (!isApiOrgConfigResults(data)) return;
+	return {
+		configs: data.configs.map((config) => validateOrganizationConfig(config)).filter((config) => config != null),
+		experiments: data.experiments.map((experiment) => ({
+			group: experiment.group,
+			groupName: experiment.group_name,
+			name: experiment.name,
+			ruleId: experiment.rule_id,
+			value: experiment.value
+		})),
+		gates: data.gates.map((gate) => ({
+			groupName: gate.group_name,
+			name: gate.name,
+			ruleId: gate.rule_id,
+			value: gate.value
+		})),
+		org: {
+			org: {
+				id: data.org.org.id,
+				displayName: data.org.org.display_name,
+				domain: data.org.org.domain,
+				shortName: data.org.org.short_name,
+				status: data.org.org.status,
+				createdAt: data.org.org.created_at?.toISOString(),
+				updatedAt: data.org.org.updated_at?.toISOString()
+			},
+			settings: {}
+		}
+	};
+};
+
+//#endregion
+//#region src/application/models/validators/validateResponse.ts
+const richInformationFromCommerceRichInformation = (data) => ({
+	cons: data.cons,
+	pros: data.pros,
+	reviewDate: data.review_date,
+	reviewerTitle: data.reviewer_title,
+	productFamiliarity: data.product_familiarity
+});
+const validateResponse = (data) => {
+	if (!require_api.isApiResponse(data)) return;
+	if (data.category === __spiffy_ai_commerce_api_client.ResponseCategory.Text && require_api.isApiTextResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.ResponseCategory.Text,
+		attributes: { content: data.attributes.content }
+	};
+	if (data.category === __spiffy_ai_commerce_api_client.ResponseCategory.Product && require_api.isApiProductResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.ResponseCategory.Product,
+		attributes: {
+			id: data.attributes.id,
+			description: data.attributes.description,
+			imageUrl: data.attributes.image_url,
+			imageUrls: data.attributes.image_urls,
+			title: data.attributes.title,
+			url: data.attributes.url,
+			originalPrice: data.attributes.original_price,
+			salePrice: data.attributes.sale_price,
+			averageRating: data.attributes.average_rating,
+			numberReviews: data.attributes.number_reviews,
+			metadata: data.attributes.metadata,
+			isForGrid: data.attributes.is_for_grid,
+			colors: data.attributes.colors,
+			sizes: data.attributes.sizes,
+			filters: data.attributes.filters
+		}
+	};
+	if (data.category === __spiffy_ai_commerce_api_client.ResponseCategory.Review && require_api.isApiReviewResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.ResponseCategory.Review,
+		attributes: {
+			id: data.attributes.id,
+			productId: data.attributes.product_id,
+			title: data.attributes.title,
+			reviewer: data.attributes.reviewer,
+			review: data.attributes.review,
+			stars: data.attributes.stars,
+			richInformation: data.attributes.rich_information ? richInformationFromCommerceRichInformation(data.attributes.rich_information) : void 0
+		}
+	};
+	if (data.category === __spiffy_ai_commerce_api_client.ResponseCategory.Separator) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.ResponseCategory.Separator
+	};
+	if (data.category === __spiffy_ai_commerce_api_client.ResponseCategory.Page && isApiPageResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.ResponseCategory.Page,
+		attributes: {
+			id: data.attributes.id,
+			title: data.attributes.title,
+			description: data.attributes.description,
+			url: data.attributes.url
+		}
+	};
+	if (data.category === __spiffy_ai_commerce_api_client.ResponseCategory.Form && isApiFormResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.ResponseCategory.Form,
+		attributes: {
+			formCategory: data.attributes.form_category ? { formType: data.attributes.form_category.form_type } : void 0,
+			schema: {
+				properties: data.attributes.schema.properties,
+				required: data.attributes.schema.required.map(String)
+			}
+		}
+	};
+	if (data.category === __spiffy_ai_commerce_api_client.ResponseCategory.ProductSearch && require_api.isApiProductSearchResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.ResponseCategory.ProductSearch,
+		attributes: {
+			generatedQuery: data.attributes.generated_query,
+			productCount: data.attributes.product_count
+		}
+	};
+	if (data.category === __spiffy_ai_commerce_api_client.ResponseCategory.ProductSearchFilter && isApiProductSearchFilterResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.ResponseCategory.ProductSearchFilter,
+		attributes: { filterName: data.attributes.filter_name }
+	};
+	if (data.category === __spiffy_ai_commerce_api_client.ResponseCategory.Order && isApiOrderResponseAttributes(data.attributes)) return {
+		id: data.id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.ResponseCategory.Order,
+		attributes: {
+			orderId: data.attributes.order_id,
+			orderNumber: data.attributes.order_number,
+			createdAt: data.attributes.created_at,
+			latestEventDate: data.attributes.latest_event_date,
+			lineItems: data.attributes.line_items.map((item) => ({
+				itemTitle: item.item_title,
+				itemPrice: item.item_price,
+				itemQuantity: item.item_quantity,
+				orderItemId: item.order_item_id,
+				image: item.image ?? void 0,
+				inTransitAt: item.in_transit_at ?? void 0,
+				deliveredAt: item.delivered_at ?? void 0,
+				estimatedDeliveryAt: item.estimated_delivery_at ?? void 0,
+				fulfillmentDisplayStatus: item.fulfillment_display_status ? stringToFulfillmentDisplayStatusEnumValue(item.fulfillment_display_status) : void 0,
+				trackingUrl: item.tracking_url ?? void 0
+			}))
+		}
+	};
+};
+
+//#endregion
+//#region src/application/models/validators/validateSuggestion.ts
+const validateSuggestion = (data) => {
+	if (!require_api.isSuggestion(data)) return;
+	return {
+		id: data.id,
+		category: data.category,
+		content: data.content,
+		createdAt: data.created_at,
+		isAnswer: data.is_answer
+	};
+};
+
+//#endregion
+//#region src/application/models/validators/validateUserEvent.ts
+const validateUserEvent = (data) => {
+	if (!require_api.isApiUserEvent(data)) return;
+	if (data.category === __spiffy_ai_commerce_api_client.UserEventCategory.PdpVisit && require_api.isApiPDPAttributes(data.attributes)) return {
+		eventId: data.event_id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.UserEventCategory.PdpVisit,
+		attributes: {
+			productId: data.attributes.product_id,
+			parentProductId: data.attributes.parent_product_id,
+			url: data.attributes.url
+		}
+	};
+	if (data.category === __spiffy_ai_commerce_api_client.UserEventCategory.QueryTyped && require_api.isApiQueryTypedAttributes(data.attributes)) return {
+		eventId: data.event_id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.UserEventCategory.QueryTyped,
+		attributes: { query: data.attributes.query }
+	};
+	if (data.category === __spiffy_ai_commerce_api_client.UserEventCategory.Search && require_api.isApiSearchAttributes(data.attributes)) return {
+		eventId: data.event_id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.UserEventCategory.Search,
+		attributes: {
+			searchTerm: data.attributes.search_term,
+			selectedFilters: data.attributes.selected_filters
+		}
+	};
+	if (data.category === __spiffy_ai_commerce_api_client.UserEventCategory.SuggestionClicked && require_api.isApiSuggestionClickedAttributes(data.attributes)) return {
+		eventId: data.event_id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.UserEventCategory.SuggestionClicked,
+		attributes: { suggestionId: data.attributes.suggestion_id }
+	};
+	if (data.category === __spiffy_ai_commerce_api_client.UserEventCategory.PlpVisit && isApiPLPEventAttributes(data.attributes)) {
+		if (isApiPLPIdAttribute(data.attributes)) return {
+			eventId: data.event_id,
+			createdAt: data.created_at,
+			category: __spiffy_ai_commerce_api_client.UserEventCategory.PlpVisit,
+			attributes: {
+				category: data.attributes.category,
+				attributes: { id: data.attributes.id }
+			}
+		};
+	}
+	if (data.category === __spiffy_ai_commerce_api_client.UserEventCategory.FormSubmitted && isApiFormSubmittedResponseAttributes(data.attributes)) return {
+		eventId: data.event_id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.UserEventCategory.FormSubmitted,
+		attributes: {
+			filledSchema: { ...data.attributes.filled_schema },
+			formResponseId: data.attributes.form_response_id,
+			formType: data.attributes.form_type
+		}
+	};
+	return {
+		eventId: data.event_id,
+		createdAt: data.created_at,
+		category: __spiffy_ai_commerce_api_client.UserEventCategory.AppLoaded
+	};
+};
+
+//#endregion
+Object.defineProperty(exports, 'ChatElementDisplayLocation', {
+  enumerable: true,
+  get: function () {
+    return ChatElementDisplayLocation;
+  }
+});
+Object.defineProperty(exports, 'GoogleAnalyticsEvents', {
+  enumerable: true,
+  get: function () {
+    return GoogleAnalyticsEvents;
+  }
+});
+Object.defineProperty(exports, 'MessageRole', {
+  enumerable: true,
+  get: function () {
+    return MessageRole;
+  }
+});
+Object.defineProperty(exports, 'MessageType', {
+  enumerable: true,
+  get: function () {
+    return MessageType;
+  }
+});
+Object.defineProperty(exports, 'OrgShortName', {
+  enumerable: true,
+  get: function () {
+    return OrgShortName;
+  }
+});
+Object.defineProperty(exports, 'ProductExperiment', {
+  enumerable: true,
+  get: function () {
+    return ProductExperiment;
+  }
+});
+Object.defineProperty(exports, 'SpiffyEventName', {
+  enumerable: true,
+  get: function () {
+    return SpiffyEventName;
+  }
+});
+Object.defineProperty(exports, 'SpiffyWidgets', {
+  enumerable: true,
+  get: function () {
+    return SpiffyWidgets;
+  }
+});
+Object.defineProperty(exports, 'getMerchantOrgIdQuery', {
+  enumerable: true,
+  get: function () {
+    return getMerchantOrgIdQuery;
+  }
+});
+Object.defineProperty(exports, 'isApiFormResponseAttributes', {
+  enumerable: true,
+  get: function () {
+    return isApiFormResponseAttributes;
+  }
+});
+Object.defineProperty(exports, 'isApiFormSubmittedResponseAttributes', {
+  enumerable: true,
+  get: function () {
+    return isApiFormSubmittedResponseAttributes;
+  }
+});
+Object.defineProperty(exports, 'isApiOrderResponseAttributes', {
+  enumerable: true,
+  get: function () {
+    return isApiOrderResponseAttributes;
+  }
+});
+Object.defineProperty(exports, 'isApiOrgConfigResults', {
+  enumerable: true,
+  get: function () {
+    return isApiOrgConfigResults;
+  }
+});
+Object.defineProperty(exports, 'isApiOrganizationConfig', {
+  enumerable: true,
+  get: function () {
+    return isApiOrganizationConfig;
+  }
+});
+Object.defineProperty(exports, 'isApiPLPEventAttributes', {
+  enumerable: true,
+  get: function () {
+    return isApiPLPEventAttributes;
+  }
+});
+Object.defineProperty(exports, 'isApiPLPIdAttribute', {
+  enumerable: true,
+  get: function () {
+    return isApiPLPIdAttribute;
+  }
+});
+Object.defineProperty(exports, 'isApiPageResponseAttributes', {
+  enumerable: true,
+  get: function () {
+    return isApiPageResponseAttributes;
+  }
+});
+Object.defineProperty(exports, 'isApiProductSearchFilterResponseAttributes', {
+  enumerable: true,
+  get: function () {
+    return isApiProductSearchFilterResponseAttributes;
+  }
+});
+Object.defineProperty(exports, 'isBaseEcommerceEvent', {
+  enumerable: true,
+  get: function () {
+    return isBaseEcommerceEvent;
+  }
+});
+Object.defineProperty(exports, 'isGA4EcommerceEvent', {
+  enumerable: true,
+  get: function () {
+    return isGA4EcommerceEvent;
+  }
+});
+Object.defineProperty(exports, 'isGraphQLColorsConfig', {
+  enumerable: true,
+  get: function () {
+    return isGraphQLColorsConfig;
+  }
+});
+Object.defineProperty(exports, 'isLegacyUAEcommerceEvent', {
+  enumerable: true,
+  get: function () {
+    return isLegacyUAEcommerceEvent;
+  }
+});
+Object.defineProperty(exports, 'isMobilePLPChatPlacementParameter', {
+  enumerable: true,
+  get: function () {
+    return isMobilePLPChatPlacementParameter;
+  }
+});
+Object.defineProperty(exports, 'isSpanxTakeAQuizCtaParameter', {
+  enumerable: true,
+  get: function () {
+    return isSpanxTakeAQuizCtaParameter;
+  }
+});
+Object.defineProperty(exports, 'isVariantInfo', {
+  enumerable: true,
+  get: function () {
+    return isVariantInfo;
+  }
+});
+Object.defineProperty(exports, 'stringToFulfillmentDisplayStatusEnumValue', {
+  enumerable: true,
+  get: function () {
+    return stringToFulfillmentDisplayStatusEnumValue;
+  }
+});
+Object.defineProperty(exports, 'transformCamelToSnake', {
+  enumerable: true,
+  get: function () {
+    return transformCamelToSnake;
+  }
+});
+Object.defineProperty(exports, 'transformSnakeToCamel', {
+  enumerable: true,
+  get: function () {
+    return transformSnakeToCamel;
+  }
+});
+Object.defineProperty(exports, 'validateAndTransformMountingConfig', {
+  enumerable: true,
+  get: function () {
+    return validateAndTransformMountingConfig;
+  }
+});
+Object.defineProperty(exports, 'validateAndTransformPageVariants', {
+  enumerable: true,
+  get: function () {
+    return validateAndTransformPageVariants;
+  }
+});
+Object.defineProperty(exports, 'validateAndTransformWidgetConfig', {
+  enumerable: true,
+  get: function () {
+    return validateAndTransformWidgetConfig;
+  }
+});
+Object.defineProperty(exports, 'validateGraphQLColorsConfig', {
+  enumerable: true,
+  get: function () {
+    return validateGraphQLColorsConfig;
+  }
+});
+Object.defineProperty(exports, 'validateGraphQLFrontendConfig', {
+  enumerable: true,
+  get: function () {
+    return validateGraphQLFrontendConfig;
+  }
+});
+Object.defineProperty(exports, 'validateGraphQLOrgId', {
+  enumerable: true,
+  get: function () {
+    return validateGraphQLOrgId;
+  }
+});
+Object.defineProperty(exports, 'validateMobilePLPChatPlacementParameter', {
+  enumerable: true,
+  get: function () {
+    return validateMobilePLPChatPlacementParameter;
+  }
+});
+Object.defineProperty(exports, 'validateOrgConfigResults', {
+  enumerable: true,
+  get: function () {
+    return validateOrgConfigResults;
+  }
+});
+Object.defineProperty(exports, 'validateOrganizationConfig', {
+  enumerable: true,
+  get: function () {
+    return validateOrganizationConfig;
+  }
+});
+Object.defineProperty(exports, 'validateResponse', {
+  enumerable: true,
+  get: function () {
+    return validateResponse;
+  }
+});
+Object.defineProperty(exports, 'validateSuggestion', {
+  enumerable: true,
+  get: function () {
+    return validateSuggestion;
+  }
+});
+Object.defineProperty(exports, 'validateUserEvent', {
+  enumerable: true,
+  get: function () {
+    return validateUserEvent;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"models-ZpQcRZQK.cjs","names":["PageVisitCategory","hasPropertyOfType","FormType","hasPropertyOfType","FormType","hasPropertyOfType","OrganizationStatusEnum","PLPAttributeCategory","result: Record<string, unknown>","FulfillmentDisplayStatus","normalizedConfig: Record<string, unknown>","PageVariantTestType","result: WidgetMountingConfig","validatedPageVariants: PageVariantConfig[]","mountingConfigsRecord: Record<string, WidgetMountingConfig>","widgetConfigsRecord: Record<string, unknown>","isApiResponse","ResponseCategory","isApiTextResponseAttributes","isApiProductResponseAttributes","isApiReviewResponseAttributes","isApiProductSearchResponseAttributes","isSuggestion","isApiUserEvent","UserEventCategory","isApiPDPAttributes","isApiQueryTypedAttributes","isApiSearchAttributes","isApiSuggestionClickedAttributes"],"sources":["../src/application/models/chatElementDisplayLocation.ts","../src/application/models/events.ts","../src/application/models/googleAnalyticsEvents.ts","../src/application/models/message.ts","../src/application/models/orgsEnum.ts","../src/application/models/productExperiment.ts","../src/application/models/spiffyWidgets.ts","../src/application/models/graphql/queries/getMerchantOrgIdQuery.ts","../src/application/models/guards/isBaseEcommerceEvent.ts","../src/application/models/guards/isGA4EcommerceEvent.ts","../src/application/models/guards/isLegacyUAEcommerceEvent.ts","../src/application/models/guards/isMobilePLPChatPlacementParameter.ts","../src/application/models/guards/isSpanxTakeAQuizCtaParameter.ts","../src/application/models/guards/isVariantInfo.ts","../src/application/models/guards/api/isApiFormResponse.ts","../src/application/models/guards/api/isApiFormSubmittedResponseAttributes.ts","../src/application/models/guards/api/isApiOrderResponseAttributes.ts","../src/application/models/guards/api/isApiOrganizationConfig.ts","../src/application/models/guards/api/isApiOrgConfigResults.ts","../src/application/models/guards/api/isApiPageResponseAttributes.ts","../src/application/models/guards/api/isApiPLPEventAttributes.ts","../src/application/models/guards/api/isApiProductSearchFilterAttributes.ts","../src/application/models/guards/graphQL/isGraphQLColorsConfig.ts","../src/application/models/utils/snakeToCamelTransformer.ts","../src/application/models/utils/stringToFulfillmentDisplayStatusEnumValue.ts","../src/application/models/validators/validateGraphQLColorsConfig.ts","../src/merchants/domInsertion.ts","../src/merchants/gridInsertion.ts","../src/application/models/validators/validateGraphQLFrontendConfig.ts","../src/application/models/validators/validateGraphQLOrgId.ts","../src/application/models/validators/validateMobilePLPChatPlacementParameter.ts","../src/application/models/validators/validateOrganizationConfig.ts","../src/application/models/validators/validateOrgConfigResults.ts","../src/application/models/validators/validateResponse.ts","../src/application/models/validators/validateSuggestion.ts","../src/application/models/validators/validateUserEvent.ts"],"sourcesContent":["// Chat element display location enum\nexport 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","// names of Spiffy specific HTML events\nexport enum SpiffyEventName {\n  WidgetOpen = 'spiffy:widgetopen',\n  WidgetClose = 'spiffy:widgetclose',\n}\n","enum GoogleAnalyticsEvents {\n  ADD_TO_CART_v1 = 'add_to_cart',\n  ADD_TO_CART_v2 = 'addToCart',\n}\n\nexport {\n  GoogleAnalyticsEvents\n}","import { CustServiceAttachment, FormType } from '@spiffy-ai/commerce-api-client';\nimport {\n  OrderResponseAttributes,\n  ProductResponseAttributes,\n  ReviewResponseAttributes,\n  PageResponseAttributes,\n  TextResponseAttributes,\n  SearchResponseAttributes,\n  SearchProductResponseAttributes,\n  AcceptableFormFieldType,\n  SearchProductFilterAttributes,\n} from './api/response';\n\nexport enum MessageRole {\n  User = 'user',\n  Assistant = 'assistant',\n}\n\nexport enum MessageType {\n  Text = 'text',\n  SuggestionClicked = 'suggestion_clicked',\n  Product = 'product',\n  ProductSearch = 'product_search',\n  Review = 'review',\n  QueryTyped = 'query_typed',\n  Separator = 'separator',\n  Page = 'page',\n  Search = 'search',\n  Attachment = 'attachment',\n  CXAgentResponse = 'cx_agent_response',\n  Form = 'form',\n  Order = 'order',\n  ProductSearchFilter = 'product_search_filter',\n}\n\nexport type Message = {\n  id: string;\n  role: MessageRole;\n  createdAt: string;\n} & (\n  | TextMessageMetadata\n  | QueryTypedMetadata\n  | SuggestionMessageMetadata\n  | ProductMessageMetadata\n  | ProductSearchMessageMetadata\n  | ReviewMessageMetadata\n  | SeparatorMessageMetadata\n  | PageMessageMetadata\n  | SearchMessageMetadata\n  | AttachmentMetadata\n  | CXAgentResponseMetadata\n  | FormMessageMetadata\n  | OrderMessageMetadata\n  | ProductSearchFilterMetadata\n);\n\ntype AttachmentMetadata = {\n  type: MessageType.Attachment;\n  metadata: {\n    message?: string;\n    attachment: CustServiceAttachment[];\n  };\n};\n\ntype CXAgentResponseMetadata = {\n  type: MessageType.CXAgentResponse;\n  metadata: {\n    message: string;\n    agentName: string;\n  };\n};\n\ntype TextMessageMetadata = {\n  type: MessageType.Text;\n  metadata: TextResponseAttributes['attributes'];\n};\n\ntype QueryTypedMetadata = {\n  type: MessageType.QueryTyped;\n  metadata: TextResponseAttributes['attributes'];\n};\n\ntype SuggestionMessageMetadata = {\n  type: MessageType.SuggestionClicked;\n  metadata: {\n    suggestionId: string;\n    suggestionContent: string;\n  };\n};\n\nexport type ProductMessageMetadata = {\n  type: MessageType.Product;\n  metadata: ProductResponseAttributes['attributes'];\n};\n\nexport type ProductSearchMessageMetadata = {\n  type: MessageType.ProductSearch;\n  metadata: SearchProductResponseAttributes['attributes'];\n};\n\ntype ReviewMessageMetadata = {\n  type: MessageType.Review;\n  metadata: ReviewResponseAttributes['attributes'];\n};\n\ntype SeparatorMessageMetadata = {\n  type: MessageType.Separator;\n};\n\ntype PageMessageMetadata = {\n  type: MessageType.Page;\n  metadata: PageResponseAttributes['attributes'];\n};\n\ntype SearchMessageMetadata = {\n  type: MessageType.Search;\n  metadata: SearchResponseAttributes['attributes'];\n};\n\ntype ProductSearchFilterMetadata = {\n  type: MessageType.ProductSearchFilter;\n  metadata: SearchProductFilterAttributes['attributes'];\n};\n\nexport type FormField = {\n  key: string;\n  title: string;\n  type: AcceptableFormFieldType;\n  required: boolean;\n  // this is the only format we currently support\n  format?: 'email';\n  value?: string;\n};\n\ntype FormMessageMetadata = {\n  type: MessageType.Form;\n  metadata: {\n    formType?: FormType;\n    fields: FormField[];\n  };\n};\n\ntype OrderMessageMetadata = {\n  type: MessageType.Order;\n  metadata: OrderResponseAttributes['attributes'];\n};\n","export const OrgShortName = {\n  Coterie: 'coterie',\n  ForLoveAndLemons: 'for-love-and-lemons',\n  Greenpan: 'greenpan',\n  JordanCraig: 'jordan-craig',\n  LarryAndSerges: 'larry_and_serges',\n  LeapsAndRebounds: 'leaps-and-rebounds',\n  MantraBrand: 'mantra-brand',\n  Spanx: 'spanx',\n  SpanxStaging: 'staging-spanx',\n  Supergoop: 'supergoop',\n  UniqueVintage: 'unique-vintage',\n  JackArcher: 'jack-archer',\n  /* -- Below items are generated by plop -- */\n  SkinPerfection: 'skin-perfection',\n  LookOptic: 'look-optic',\n  FiveCbd: 'five-cbd',\n  SnapSupplements: 'snap-supplements',\n  Longevityrx: 'longevityrx',\n  VenaCbd: 'vena-cbd',\n  Medterra: 'medterra',\n  Modells: 'modells',\n  PressedFloral: 'pressed-floral',\n  KindredBravely: 'kindred-bravely',\n  WineEnthusiast: 'wine-enthusiast',\n  HomegrownCannabis: 'homegrown-cannabis',\n  DreamlandBaby: 'dreamland-baby',\n  Bandolier: 'bandolier',\n  WestonJonBoucher: 'weston-jon-boucher',\n  KutFromTheKloth: 'kut-from-the-kloth',\n  GrooveLife: 'groove-life',\n  Carpe: 'carpe',\n  WolfTactical: 'wolf-tactical',\n  WolfMattress: 'wolfmattress',\n  Default: 'default',\n} as const;\n","export enum ProductExperiment {\n  // Default is only used to ensure that the enum is non-empty, otherwise\n  // callers that try to use this enum will generate a typescript error\n  Default = 'default',\n}\n","/**\n * Enum of all widget names. These are widgets that are rendered and integrated into\n * a merchant's website.\n */\nexport enum SpiffyWidgets {\n  ImageBanner = 'image_banner',\n  ImagePromptCard = 'image_prompt_card',\n  SingleImagePrompt = 'single_image_prompt',\n  EmbeddedWidget = 'embedded_widget',\n  FloatingButton = 'floating_button',\n  SuggestionBar = 'suggestion_bar',\n  SearchPrompt = 'search_prompt',\n  GlobalSearch = 'global_search',\n  SearchResults = 'search_results',\n  GlobalSearchEntryPoint = 'global_search_entry_point',\n}\n","const getMerchantOrgIdQuery = `\n  query {\n    me {\n      org {\n        id\n      }\n    }\n  }\n`;\n\nexport { getMerchantOrgIdQuery };\n","import type { BaseEcommerceEvent } from 'src/application/models';\n\n/**\n * Checks if an event is a base Google Analytics ecommerce event.\n *\n * @param data The event to check.\n *\n * @returns True if the event is a base ecommerce event, false otherwise.\n */\nexport const isBaseEcommerceEvent = (data: unknown): data is BaseEcommerceEvent =>\n  data != null &&\n  typeof data === 'object' &&\n  'ecommerce' in data &&\n  data.ecommerce != null &&\n  typeof data.ecommerce === 'object' &&\n  'event' in data &&\n  typeof data.event === 'string';\n","import type { GA4EcommerceEvent } from 'src/application/models';\n\n/**\n * Checks if an event is a Google Analytics 4 ecommerce event.\n *\n * @param data The event to check.\n *\n * @returns True if the event is a GA4 ecommerce event, false otherwise.\n */\nexport const isGA4EcommerceEvent = (data: unknown): data is GA4EcommerceEvent =>\n  typeof data === 'object' &&\n  data != null &&\n  'ecommerce' in data &&\n  data.ecommerce != null &&\n  typeof data.ecommerce === 'object' &&\n  'items' in data.ecommerce &&\n  Array.isArray(data.ecommerce.items);\n","import type { UAEcommerceEvent } from 'src/application/models';\n\n/**\n * Checks if an event is a legacy Universal Analytics ecommerce event.\n *\n * @param data The event to check.\n *\n * @returns True if the event is a legacy UA ecommerce event, false otherwise.\n */\nexport const isLegacyUAEcommerceEvent = (data: unknown): data is UAEcommerceEvent =>\n  data != null &&\n  typeof data === 'object' &&\n  'ecommerce' in data &&\n  data.ecommerce != null &&\n  typeof data.ecommerce === 'object' &&\n  'add' in data.ecommerce &&\n  typeof data.ecommerce.add === 'object';\n","interface MobilePlpChatPlacementParameter {\n  row_index: number;\n}\n\nexport const isMobilePLPChatPlacementParameter = (\n  value: unknown,\n): value is MobilePlpChatPlacementParameter =>\n  value != null &&\n  typeof value === 'object' &&\n  'row_index' in value &&\n  typeof value.row_index === 'number';\n","import { SpanxTakeAQuizCtaParameter } from '../spanxTakeAQuizCtaParameter';\n\nexport const isSpanxTakeAQuizCtaParameter = (value: unknown): value is SpanxTakeAQuizCtaParameter =>\n  value != null && typeof value === 'object' && 'text' in value && typeof value.text === 'string';","import { PageVisitCategory } from '@spiffy-ai/commerce-api-client';\nimport { PDPVariantInfo, PLPVariantInfo, PageVisitVariantInfo, VariantInfo } from '../variantInfo';\n\nconst isPDPVariantInfo = (variantInfo: object): variantInfo is PDPVariantInfo =>\n  'variant' in variantInfo &&\n  variantInfo.variant === 'pdp' &&\n  'productId' in variantInfo &&\n  typeof variantInfo.productId === 'string';\n\nconst isPLPVariantInfo = (variantInfo: object): variantInfo is PLPVariantInfo =>\n  'variant' in variantInfo &&\n  variantInfo.variant === 'plp' &&\n  'plpId' in variantInfo &&\n  typeof variantInfo.plpId === 'string';\n\nconst isPageVisitVariantInfo = (variantInfo: object): variantInfo is PageVisitVariantInfo =>\n  'variant' in variantInfo &&\n  variantInfo.variant === 'page_visit' &&\n  'url' in variantInfo &&\n  typeof variantInfo.url === 'string' &&\n  'pageVisitCategory' in variantInfo &&\n  Object.values(PageVisitCategory).includes(variantInfo.pageVisitCategory as PageVisitCategory);\n\n/**\n * Type guard to check if an object is a valid VariantInfo.\n *\n * @param variantInfo - The unknown object to check.\n *\n * @returns True if the data is a valid VariantInfo object, false otherwise.\n */\nexport const isVariantInfo = (variantInfo: unknown): variantInfo is VariantInfo =>\n  variantInfo != null &&\n  typeof variantInfo === 'object' &&\n  'variantId' in variantInfo &&\n  (isPDPVariantInfo(variantInfo) ||\n    isPLPVariantInfo(variantInfo) ||\n    isPageVisitVariantInfo(variantInfo));\n","import Logger from 'src/application/logging/logger';\nimport { FormType } from '@spiffy-ai/commerce-api-client';\nimport { ApiFormResponseAttributes } from 'src/application/models/api/responseGenerics';\nimport { hasPropertyOfType } from 'src/application/models/guards/utils';\n\n/**\n * Type guard to check if the provided data has the all of the properties (with the correct types) of\n * a FormResponseAttribute\n *\n * @param data - The data to check\n *\n * @returns true if the data has the correct properties, false otherwise\n */\nexport const isApiFormResponseAttributes = (data: unknown): data is ApiFormResponseAttributes => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logError('isApiFormResponseAttributes: data is null or not an object', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if ('form_category' in data && typeof data.form_category !== 'object') {\n    Logger.logError('isApiFormResponseAttributes: form_category is not an object', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if ('form_category' in data && typeof data.form_category === 'object') {\n    if (\n      !hasPropertyOfType(data.form_category, 'form_type', 'string') ||\n      !Object.values(FormType).includes(data.form_category.form_type as FormType)\n    ) {\n      Logger.logError(\n        'isApiFormResponseAttributes: form_type is missing or not a valid form type',\n        undefined,\n        {\n          data,\n        },\n      );\n      return false;\n    }\n  }\n\n  if (!hasPropertyOfType(data, 'schema', 'object')) {\n    Logger.logError('isApiFormResponseAttributes: schema is missing or not an object', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  // TODO: also wanna validate the fields of data.schema.properties but might wanna change the schema\n  // to not have the property name as a key in the object\n  if (!hasPropertyOfType(data.schema, 'properties', 'object')) {\n    Logger.logError(\n      'isApiFormResponseAttributes: schema.properties is missing or not an object',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  if (!hasPropertyOfType(data.schema, 'required', 'array')) {\n    Logger.logError(\n      'isApiFormResponseAttributes: schema.required is missing or not an array',\n      undefined,\n      { data },\n    );\n    return false;\n  }\n\n  if (\n    !data.schema.required.every(\n      (key: unknown) => typeof key === 'string' && key in data.schema.properties,\n    )\n  ) {\n    Logger.logError(\n      'isApiFormResponseAttributes: schema.required contains invalid property keys',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  return true;\n};\n","import Logger from 'src/application/logging/logger';\nimport { FormSubmittedAttributes, FormType } from '@spiffy-ai/commerce-api-client';\nimport { hasPropertyOfType } from 'src/application/models/guards/utils';\n\nexport const isApiFormSubmittedResponseAttributes = (\n  data: unknown,\n): data is FormSubmittedAttributes => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logError('isApiFormSubmittedResponseAttributes', 'data is null or not an object', data);\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'filled_schema', 'object')) {\n    Logger.logError('isApiFormSubmittedResponseAttributes', 'filled_schema is not an object', data);\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'form_response_id', 'string')) {\n    Logger.logError(\n      'isApiFormSubmittedResponseAttributes',\n      'form_response_id is not a string',\n      data,\n    );\n    return false;\n  }\n\n  if (!('form_type' in data) || !Object.values(FormType).includes(data.form_type as FormType)) {\n    Logger.logError(\n      'isApiFormSubmittedResponseAttributes',\n      'form_type is not a valid form type enum',\n      data,\n    );\n    return false;\n  }\n\n  return true;\n};\n","import Logger from 'src/application/logging/logger';\nimport { OrderItemInfo, OrderResponseAttributes } from '@spiffy-ai/commerce-api-client';\nimport { hasPropertyOfType } from 'src/application/models/guards/utils';\n\n// the client SDK generates date-time format types as `Date` but the openapi typescript generator\n// does not correctly deserialize date-time values so they are always `string` at runtime instead of\n// `Date` objects. These interfaces override the SDK types so that we can validate against the actual\n// `string` values. https://github.com/OpenAPITools/openapi-generator/issues/926\nexport interface ApiOrderItemInfo\n  extends Omit<OrderItemInfo, 'delivered_at' | 'estimated_delivery_at' | 'in_transit_at'> {\n  delivered_at?: string;\n  estimated_delivery_at?: string;\n  in_transit_at?: string;\n}\n\nexport interface ApiOrderResponseAttributes\n  extends Omit<OrderResponseAttributes, 'created_at' | 'latest_event_date' | 'line_items'> {\n  created_at: string;\n  latest_event_date: string;\n  line_items: ApiOrderItemInfo[];\n}\n\nconst isApiOrderItemInfo = (data: unknown): data is ApiOrderItemInfo => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logError('OrderItemInfo must be an object', undefined, { data });\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'order_item_id', 'string')) {\n    Logger.logError('OrderItemInfo must have an order_item_id property', undefined, { data });\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'item_title', 'string')) {\n    Logger.logError('OrderItemInfo must have an item_title property', undefined, { data });\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'item_price', 'number')) {\n    Logger.logError('OrderItemInfo must have an item_price property', undefined, { data });\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'item_quantity', 'number')) {\n    Logger.logError('OrderItemInfo must have an item_quantity property', undefined, { data });\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'image', 'string', true)) {\n    Logger.logError('OrderItemInfo.image must be a string or null', undefined, { data });\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'fulfillment_display_status', 'string', true)) {\n    Logger.logError(\n      'OrderItemInfo.fulfillment_display_status must be a string or null',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'tracking_url', 'string', true)) {\n    Logger.logError('OrderItemInfo.tracking_url must be a string or null', undefined, { data });\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'delivered_at', 'string', true)) {\n    Logger.logError('OrderItemInfo.delivered_at must be a string or null', undefined, { data });\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'estimated_delivery_at', 'string', true)) {\n    Logger.logError('OrderItemInfo.estimated_delivery_at must be a string or null', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'in_transit_at', 'string', true)) {\n    Logger.logError('OrderItemInfo.in_transit_at must be a string or null', undefined, { data });\n    return false;\n  }\n\n  return true;\n};\n\nexport const isApiOrderResponseAttributes = (data: unknown): data is ApiOrderResponseAttributes => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logError('Order response attributes must be an object', undefined, { data });\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'created_at', 'string')) {\n    Logger.logError(\n      'Order response attributes must have a created_at property and have type string',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'latest_event_date', 'string')) {\n    Logger.logError(\n      'Order response attributes must have a latest_event_date property and have type string',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  if (\n    !hasPropertyOfType(data, 'line_items', 'array') ||\n    !data.line_items.every((item: unknown) => isApiOrderItemInfo(item))\n  ) {\n    Logger.logError(\n      'Order response attributes must have a line_items property with at least one order item',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'order_id', 'string')) {\n    Logger.logError(\n      'Order response attributes must have an order_id property and have type string',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  if (!hasPropertyOfType(data, 'order_number', 'string')) {\n    Logger.logError(\n      'Order response attributes must have an order_number property and have type string',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  return true;\n};\n","import Logger from 'src/application/logging/logger';\nimport { OrganizationConfig } from '@spiffy-ai/commerce-api-client';\n\n// the \"config\" property is a generic object in the commerce api spec, these interfaces\n// are used to validate the structure of that object and to transform the api response\n// into a typed object for the frontend. Do not use these interfaces for anything else.\ninterface ApiOrgAnalyticsConfigAmplitude {\n  session_replay_enabled: boolean;\n  session_replay_sample_rate: number;\n  tracking_enabled: boolean;\n}\n\ninterface ApiOrgAnalyticsConfigCustomerService {\n  provider: string;\n}\n\ninterface ApiOrgAnalyticsConfigGoogleAnalytics {\n  measurement_id: string;\n}\n\ninterface ApiOrgAnalyticsConfig {\n  amplitude?: ApiOrgAnalyticsConfigAmplitude;\n  customer_service?: ApiOrgAnalyticsConfigCustomerService;\n  google_analytics?: ApiOrgAnalyticsConfigGoogleAnalytics;\n}\n\nexport interface ApiOrganizationConfig extends OrganizationConfig {\n  config: ApiOrgAnalyticsConfig;\n}\n\nconst isApiOrgAnalyticsConfigAmplitude = (\n  data: unknown,\n): data is ApiOrgAnalyticsConfigAmplitude => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logDebug('[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: data is not an object', data);\n    return false;\n  }\n\n  if (!('session_replay_enabled' in data) || typeof data.session_replay_enabled !== 'boolean') {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: session_replay_enabled is not a boolean',\n      data,\n    );\n    return false;\n  }\n\n  if (\n    !('session_replay_sample_rate' in data) ||\n    typeof data.session_replay_sample_rate !== 'number'\n  ) {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: session_replay_sample_rate is not a number',\n      data,\n    );\n    return false;\n  }\n\n  if (!('tracking_enabled' in data) || typeof data.tracking_enabled !== 'boolean') {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgAnalyticsConfigAmplitude: tracking_enabled is not a boolean',\n      data,\n    );\n    return false;\n  }\n\n  return true;\n};\n\nconst isApiOrgAnalyticsConfigCustomerService = (\n  data: unknown,\n): data is ApiOrgAnalyticsConfigCustomerService => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgAnalyticsConfigCustomerService: data is not an object',\n      data,\n    );\n    return false;\n  }\n\n  if (!('provider' in data) || typeof data.provider !== 'string') {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgAnalyticsConfigCustomerService: provider is not a string',\n      data,\n    );\n    return false;\n  }\n\n  return true;\n};\n\nconst isApiOrgAnalyticsConfigGoogleAnalytics = (\n  data: unknown,\n): data is ApiOrgAnalyticsConfigGoogleAnalytics => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgAnalyticsConfigGoogleAnalytics: data is not an object',\n      data,\n    );\n    return false;\n  }\n\n  if (!('measurement_id' in data) || typeof data.measurement_id !== 'string') {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgAnalyticsConfigGoogleAnalytics: measurement_id is not a string',\n      data,\n    );\n    return false;\n  }\n\n  return true;\n};\n\n/**\n *\n * @param data\n * @returns\n */\nconst isApiOrgAnalyticsConfig = (data: unknown): data is ApiOrgAnalyticsConfig => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logDebug('[spiffy-ai] isOrgAnalyticsConfig: data is not an object', data);\n    return false;\n  }\n\n  if (\n    'amplitude' in data &&\n    !isApiOrgAnalyticsConfigAmplitude(data.amplitude)\n  ) {\n    Logger.logDebug('[spiffy-ai] isOrgAnalyticsConfig: amplitude is not an object', data);\n    return false;\n  }\n\n  if (\n    'customer_service' in data &&\n    !isApiOrgAnalyticsConfigCustomerService(data.customer_service)\n  ) {\n    Logger.logDebug('[spiffy-ai] isOrgAnalyticsConfig: customer_service is not an object', data);\n    return false;\n  }\n\n  if (\n    'google_analytics' in data &&\n    !isApiOrgAnalyticsConfigGoogleAnalytics(data.google_analytics)\n  ) {\n    Logger.logDebug('[spiffy-ai] isOrgAnalyticsConfig: google_analytics is not an object', data);\n    return false;\n  }\n\n  return true;\n};\n\n/**\n *\n * @param data\n * @returns\n */\nexport const isApiOrganizationConfig = (data: unknown): data is ApiOrganizationConfig => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logDebug('[spiffy-ai] isOrgConfig: data is not an object', data);\n    return false;\n  }\n\n  if (!('created_at' in data)) {\n    Logger.logDebug('[spiffy-ai] isOrgConfig: created_at is not defined', data);\n    return false;\n  }\n\n  if (!('namespace' in data) || typeof data.namespace !== 'string') {\n    Logger.logDebug('[spiffy-ai] isOrgConfig: namespace is not a string', data);\n    return false;\n  }\n\n  if (!('is_latest' in data) || typeof data.is_latest !== 'boolean') {\n    Logger.logDebug('[spiffy-ai] isOrgConfig: is_latest is not a boolean', data);\n    return false;\n  }\n\n  if (!('version' in data) || typeof data.version !== 'string') {\n    Logger.logDebug('[spiffy-ai] isOrgConfig: version is not a string', data);\n    return false;\n  }\n\n  if (!('updated_at' in data)) {\n    Logger.logDebug('[spiffy-ai] isOrgConfig: updated_at is not defined', data);\n    return false;\n  }\n\n  if (\n    !('config' in data) ||\n    typeof data.config !== 'object' ||\n    !isApiOrgAnalyticsConfig(data.config)\n  ) {\n    Logger.logDebug('[spiffy-ai] isOrgConfig: config is not an object', data);\n    return false;\n  }\n\n  if ('organization_id' in data && typeof data.organization_id !== 'string') {\n    Logger.logDebug('[spiffy-ai] isOrgConfig: organization_id is not a string', data);\n    return false;\n  }\n\n  if ('id' in data && typeof data.id !== 'string') {\n    Logger.logDebug('[spiffy-ai] isOrgConfig: id is not a string', data);\n    return false;\n  }\n\n  return true;\n};\n","import Logger from 'src/application/logging/logger';\nimport {\n  StatsigExperiment as ApiOrgConfigExperiment,\n  StatsigFeatureGate as ApiOrgConfigFeatureGate,\n  OrganizationSettings as ApiOrgConfigOrganizationSettings,\n  Organization as ApiOrganization,\n  OrganizationStatusEnum,\n} from '@spiffy-ai/commerce-api-client';\nimport { ApiOrganizationConfig, isApiOrganizationConfig } from './isApiOrganizationConfig';\n\ninterface ApiOrgConfigResults {\n  configs: ApiOrganizationConfig[];\n  experiments: ApiOrgConfigExperiment[];\n  gates: ApiOrgConfigFeatureGate[];\n  org: ApiOrgConfigOrganizationSettings;\n}\n\nconst isApiOrgConfigExperiment = (data: unknown): data is ApiOrgConfigExperiment => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logDebug('[spiffy-ai] isApiOrgConfigExperiment: data is not an object', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if ('group' in data && typeof data.group !== 'string' && data.group !== undefined) {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgConfigExperiment: group is not a string or undefined',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  if (\n    'group_name' in data &&\n    typeof data.group_name !== 'string' &&\n    data.group_name !== undefined\n  ) {\n    Logger.logDebug('[spiffy-ai] isApiOrgConfigExperiment: group_name is not a string', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if ('name' in data && typeof data.name !== 'string' && data.name !== undefined) {\n    Logger.logDebug('[spiffy-ai] isApiOrgConfigExperiment: name is not a string', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if ('rule_id' in data && typeof data.rule_id !== 'string' && data.rule_id !== undefined) {\n    Logger.logDebug('[spiffy-ai] isApiOrgConfigExperiment: rule_id is not a string', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if ('value' in data && typeof data.value !== 'object' && data.value !== undefined) {\n    Logger.logDebug('[spiffy-ai] isApiOrgConfigExperiment: value is not an object', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  return true;\n};\n\nconst isApiOrgConfigFeatureGate = (data: unknown): data is ApiOrgConfigFeatureGate => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logDebug('[spiffy-ai] isApiOrgConfigFeatureGate: data is not an object', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if ('name' in data && typeof data.name !== 'string' && data.name !== undefined) {\n    Logger.logDebug('[spiffy-ai] isApiOrgConfigFeatureGate: name is not a string', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if ('rule_id' in data && typeof data.rule_id !== 'string' && data.rule_id !== undefined) {\n    Logger.logDebug('[spiffy-ai] isApiOrgConfigFeatureGate: rule_id is not a string', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if ('value' in data && typeof data.value !== 'boolean' && data.value !== undefined) {\n    Logger.logDebug('[spiffy-ai] isApiOrgConfigFeatureGate: value is not a boolean', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  return true;\n};\n\nconst isApiOrganization = (data: unknown): data is ApiOrganization => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logDebug('[spiffy-ai] isApiOrganization: data is not an object', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if (!('id' in data) || typeof data.id !== 'string') {\n    Logger.logDebug('[spiffy-ai] isApiOrganization: id is not a string', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if (!('display_name' in data) || typeof data.display_name !== 'string') {\n    Logger.logDebug('[spiffy-ai] isApiOrganization: display_name is not a string', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if (!('domain' in data) || typeof data.domain !== 'string') {\n    Logger.logDebug('[spiffy-ai] isApiOrganization: domain is not a string', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if (!('short_name' in data) || typeof data.short_name !== 'string') {\n    Logger.logDebug('[spiffy-ai] isApiOrganization: short_name is not a string', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if (\n    !('status' in data) ||\n    !Object.values(OrganizationStatusEnum).includes(data.status as OrganizationStatusEnum)\n  ) {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrganization: status is not a valid OrganizationStatusEnum value',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  if (\n    'created_at' in data &&\n    !(data.created_at instanceof Date) &&\n    typeof data.created_at !== 'string' &&\n    data.created_at !== undefined\n  ) {\n    Logger.logDebug('[spiffy-ai] isApiOrganization: created_at is not a Date', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if (\n    'updated_at' in data &&\n    !(data.updated_at instanceof Date) &&\n    typeof data.updated_at !== 'string' &&\n    data.updated_at !== undefined\n  ) {\n    Logger.logDebug('[spiffy-ai] isApiOrganization: updated_at is not a Date', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  return true;\n};\n\nconst isApiOrgConfigOrganizationSettings = (\n  data: unknown,\n): data is ApiOrgConfigOrganizationSettings => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgConfigOrganizationSettings: data is not an object',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  if (!('org' in data) || !isApiOrganization(data.org)) {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgConfigOrganizationSettings: org is not an object',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  // skip validation for 'settings' for now\n\n  return true;\n};\n\n/**\n *\n * @param data\n * @returns\n */\nexport const isApiOrgConfigResults = (data: unknown): data is Required<ApiOrgConfigResults> => {\n  if (data == null || typeof data !== 'object') {\n    Logger.logDebug('[spiffy-ai] isApiOrgConfigResults: data is not an object', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if (\n    !('configs' in data) ||\n    !Array.isArray(data.configs) ||\n    !data.configs.every((config) => isApiOrganizationConfig(config))\n  ) {\n    Logger.logDebug('[spiffy-ai] isApiOrgConfigResults: configs is not an array', undefined, {\n      data,\n    });\n    return false;\n  }\n\n  if (\n    'experiments' in data &&\n    data.experiments !== undefined &&\n    (!Array.isArray(data.experiments) ||\n      !data.experiments.every((exp) => isApiOrgConfigExperiment(exp)))\n  ) {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgConfigResults: experiments is not an array or contains invalid items',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  if (\n    !('gates' in data) ||\n    !Array.isArray(data.gates) ||\n    !data.gates.every((gate) => isApiOrgConfigFeatureGate(gate))\n  ) {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgConfigResults: gates is not an array or contains invalid items',\n      undefined,\n      {\n        data,\n      },\n    );\n    return false;\n  }\n\n  if (!('org' in data) || !isApiOrgConfigOrganizationSettings(data.org)) {\n    Logger.logDebug(\n      '[spiffy-ai] isApiOrgConfigResults: org is not an object or has invalid fields',\n      undefined,\n      { data },\n    );\n\n    return false;\n  }\n\n  return true;\n};\n","import { ApiPageResponseAttributes } from 'src/application/models/api/responseGenerics';\n\nexport const isApiPageResponseAttributes = (obj: unknown): obj is ApiPageResponseAttributes => {\n  if (obj == null || typeof obj !== 'object') {\n    return false;\n  }\n\n  if ('title' in obj && obj.title != null && typeof obj.title !== 'string') {\n    return false;\n  }\n\n  if ('description' in obj && typeof obj.description !== 'string') {\n    return false;\n  }\n\n  if ('url' in obj && typeof obj.url !== 'string') {\n    return false;\n  }\n\n  return true;\n};\n","import {\n  PLPAttributeCategory,\n  PLPAttributes,\n  PLPIdAttributes,\n} from '@spiffy-ai/commerce-api-client';\n\nexport const isApiPLPIdAttribute = (data: unknown): data is PLPIdAttributes => {\n  if (data == null || typeof data !== 'object') {\n    return false;\n  }\n\n  if (!('id' in data) || typeof data.id !== 'string') {\n    return false;\n  }\n\n  return true;\n};\n\nexport const isApiPLPEventAttributes = (data: unknown): data is PLPAttributes => {\n  if (data == null || typeof data !== 'object') {\n    return false;\n  }\n\n  if (\n    !('category' in data) ||\n    typeof data.category !== 'string' ||\n    !Object.values(PLPAttributeCategory).includes(data.category as PLPAttributeCategory)\n  ) {\n    return false;\n  }\n\n  if (\n    !('attributes' in data) ||\n    typeof data.attributes !== 'object' ||\n    !isApiPLPIdAttribute(data.attributes)\n  ) {\n    return false;\n  }\n\n  return true;\n};\n","import { ProductSearchFilterResponseAttributes } from '@spiffy-ai/commerce-api-client';\n\nexport const isApiProductSearchFilterResponseAttributes = (\n  attributes: unknown,\n): attributes is ProductSearchFilterResponseAttributes => {\n  if (attributes == null || typeof attributes !== 'object') {\n    return false;\n  }\n\n  if ('filter_name' in attributes && typeof attributes.filter_name !== 'string') {\n    return false;\n  }\n\n  return true;\n};\n","import Logger from 'src/application/logging/logger';\nimport { GetMerchantColorsQueryData } from 'src/application/models/graphql';\n\nconst REQUIRED_COLOR_FIELDS = [\n  'accent_primary',\n  'accent_secondary',\n  'background_dark',\n  'background_light',\n  'background_primary',\n  'background_saturated',\n  'background_secondary',\n  'background_secondary_dark',\n  'background_tertiary',\n  'border_dark',\n  'border_light',\n  'border_medium',\n  'border_outline',\n  'text_accent',\n  'text_light',\n  'text_link',\n  'text_primary',\n  'text_secondary',\n] as const;\n\nexport const isGraphQLColorsConfig = (data: unknown): data is GetMerchantColorsQueryData => {\n  if (typeof data !== 'object' || data === null) {\n    Logger.logError('Invalid graphql response for colors config', undefined, { data });\n    return false;\n  }\n\n  // Check each required field\n  const missingFields = REQUIRED_COLOR_FIELDS.filter(\n    (field) => !(field in data) || typeof (data as Record<string, unknown>)[field] !== 'string',\n  );\n\n  if (missingFields.length === REQUIRED_COLOR_FIELDS.length) {\n    Logger.logError('All color fields are missing or null', undefined);\n    return false;\n  }\n\n  if (missingFields.length > 0) {\n    Logger.logError('Missing or invalid color fields', undefined, {\n      data,\n      missingFields,\n    });\n    return false;\n  }\n\n  return true;\n};\n","/**\n * Generic utility to transform snake_case object keys to camelCase at runtime.\n * This is the runtime equivalent of the CamelCasedPropertiesDeep type utility.\n */\n\n// List of acronyms that should be preserved as uppercase in camelCase and lowercase in snake_case\nconst PRESERVED_ACRONYMS = [\"PLP\", \"PDP\", \"SVG\"];\n\n/**\n * Converts a snake_case string to camelCase\n * Handles specific acronyms like PLP and PDP correctly\n */\nconst toCamelCase = (str: string): string => {\n  // Pre-process: convert all words that match the PRESERVED_ACRONYMS regex to uppercase\n  let processedStr = str;\n  for (const acronym of PRESERVED_ACRONYMS) {\n    const regex = new RegExp(`_${acronym}_?`, \"gi\");\n\n    if (processedStr.match(regex)) {\n      processedStr = processedStr.replace(regex, (v) =>\n        v.endsWith(\"_\") ? `${acronym}_` : `${acronym}`\n      );\n    }\n  }\n  return processedStr.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());\n};\n\n/**\n * Converts a camelCase string to snake_case\n * Handles consecutive capital letters correctly (e.g., \"PDP\" -> \"pdp\", not \"p_d_p\")\n * Preserves specific acronyms like PLP and PDP as lowercase in snake_case\n */\nconst toSnakeCase = (str: string) =>\n  str\n    .replace(/([A-Z])(?=[a-z])/g, \"_$1\")\n    .replace(/([a-z])([A-Z])/g, \"$1_$2\")\n    .toLowerCase()\n    .replace(/^_/, \"\");\n\n/**\n * Recursively transforms all object keys from snake_case to camelCase\n */\nexport const transformSnakeToCamel = (obj: unknown): unknown => {\n  if (obj === null || obj === undefined) {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((val) => transformSnakeToCamel(val));\n  }\n\n  if (typeof obj === \"object\") {\n    const result: Record<string, unknown> = {};\n\n    for (const [key, value] of Object.entries(obj)) {\n      const camelKey = toCamelCase(key);\n      result[camelKey] = transformSnakeToCamel(value);\n    }\n\n    return result;\n  }\n\n  return obj;\n};\n\n/**\n * Recursively transforms all object keys from camelCase to snake_case\n */\nexport const transformCamelToSnake = (obj: unknown): unknown => {\n  if (obj === null || obj === undefined) {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map(transformCamelToSnake);\n  }\n\n  if (typeof obj === \"object\") {\n    const result: Record<string, unknown> = {};\n\n    for (const [key, value] of Object.entries(obj)) {\n      const snakeKey = toSnakeCase(key);\n      result[snakeKey] = transformCamelToSnake(value);\n    }\n\n    return result;\n  }\n\n  return obj;\n};\n","import { FulfillmentDisplayStatus } from '@spiffy-ai/commerce-api-client';\n\n/**\n * Converts a string to a FulfillmentDisplayStatus enum value.\n *\n * @param status - The string to convert.\n *\n * @returns The FulfillmentDisplayStatus enum value or undefined if the string\n * does not map to a valid enum\n */\nexport const stringToFulfillmentDisplayStatusEnumValue = (\n  status: string,\n): FulfillmentDisplayStatus | undefined => {\n  switch (status) {\n    case 'ATTEMPTED_DELIVERY':\n      return FulfillmentDisplayStatus.ATTEMPTED_DELIVERY;\n    case 'CANCELED':\n      return FulfillmentDisplayStatus.CANCELED;\n    case 'CONFIRMED':\n      return FulfillmentDisplayStatus.CONFIRMED;\n    case 'DELIVERED':\n      return FulfillmentDisplayStatus.DELIVERED;\n    case 'FAILURE':\n      return FulfillmentDisplayStatus.FAILURE;\n    case 'FULFILLED':\n      return FulfillmentDisplayStatus.FULFILLED;\n    case 'IN_TRANSIT':\n      return FulfillmentDisplayStatus.IN_TRANSIT;\n    case 'LABEL_PRINTED':\n      return FulfillmentDisplayStatus.LABEL_PRINTED;\n    case 'LABEL_PURCHASED':\n      return FulfillmentDisplayStatus.LABEL_PURCHASED;\n    case 'LABEL_VOIDED':\n      return FulfillmentDisplayStatus.LABEL_VOIDED;\n    case 'MARKED_AS_FULFILLED':\n      return FulfillmentDisplayStatus.MARKED_AS_FULFILLED;\n    case 'NOT_DELIVERED':\n      return FulfillmentDisplayStatus.NOT_DELIVERED;\n    case 'OUT_FOR_DELIVERY':\n      return FulfillmentDisplayStatus.OUT_FOR_DELIVERY;\n    case 'PICKED_UP':\n      return FulfillmentDisplayStatus.PICKED_UP;\n    case 'READY_FOR_PICKUP':\n      return FulfillmentDisplayStatus.READY_FOR_PICKUP;\n    case 'SUBMITTED':\n      return FulfillmentDisplayStatus.SUBMITTED;\n    case 'IN_PROGRESS':\n      return FulfillmentDisplayStatus.IN_PROGRESS;\n    case 'ON_HOLD':\n      return FulfillmentDisplayStatus.ON_HOLD;\n    case 'OPEN':\n      return FulfillmentDisplayStatus.OPEN;\n    case 'PARTIALLY_FULFILLED':\n      return FulfillmentDisplayStatus.PARTIALLY_FULFILLED;\n    case 'PENDING_FULFILLMENT':\n      return FulfillmentDisplayStatus.PENDING_FULFILLMENT;\n    case 'REQUEST_DECLINED':\n      return FulfillmentDisplayStatus.REQUEST_DECLINED;\n    case 'RESTOCKED':\n      return FulfillmentDisplayStatus.RESTOCKED;\n    case 'SCHEDULED':\n      return FulfillmentDisplayStatus.SCHEDULED;\n    case 'UNFULFILLED':\n      return FulfillmentDisplayStatus.UNFULFILLED;\n    default:\n      return undefined;\n  }\n};\n","import { ColorMapping, ColorNames } from \"src/application/models/colorsConfig\";\nimport { isGraphQLColorsConfig } from \"src/application/models/guards/graphQL/isGraphQLColorsConfig\";\n\nexport const validateGraphQLColorsConfig = (\n  data: unknown\n): ColorMapping | undefined => {\n  if (!isGraphQLColorsConfig(data)) {\n    return undefined;\n  }\n};\n","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}\n\nexport const DOMInsertionTypeToInsertPosition = (\n  type: DOMInsertionType\n): InsertPosition => {\n  switch (type) {\n    case DOMInsertionType.ADJACENT_AFTER_BEGIN:\n      return \"afterbegin\";\n    case DOMInsertionType.BEFORE:\n    case DOMInsertionType.ADJACENT_BEFORE_BEGIN:\n      return \"beforebegin\";\n    case DOMInsertionType.ADJACENT_BEFORE_END:\n      return \"beforeend\";\n    case DOMInsertionType.AFTER:\n    case DOMInsertionType.ADJACENT_AFTER_END:\n    default:\n      return \"afterend\";\n  }\n};\n\nexport { DOMInsertionType };\n","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}\n\nexport { GridInsertionType };\n","import { FrontendConfig } from 'src/application/models/frontendConfig';\nimport { transformSnakeToCamel } from 'src/application/models/utils/snakeToCamelTransformer';\nimport {\n  WidgetConfig,\n  PageVariantConfig,\n  PageVariantTestType,\n  WidgetMountingConfig,\n} from 'src/contexts/types';\nimport { DOMInsertionType } from 'src/merchants/domInsertion';\nimport { GridInsertionType } from 'src/merchants/gridInsertion';\nimport Logger from 'src/application/logging/logger';\n\n// Helper function to validate and transform PageVariantQueryData to PageVariantConfig\nexport const validateAndTransformPageVariants = (\n  config: Record<string, unknown>,\n): PageVariantConfig => {\n  const transformed = transformSnakeToCamel(config) as Record<string, unknown>;\n\n  const { variantChecks, widgetMounting, ...rest } = transformed;\n\n  // Convert variantChecks to variantTests with testType normalization\n  const variantTests = Array.isArray(variantChecks)\n    ? variantChecks.map(({ checkType, ...restCheck }) => ({\n        ...restCheck,\n        testType: checkType,\n      }))\n    : [];\n\n  // Normalize widgetMounting: checks -> tests, checkType -> testType\n  const normalizedWidgetMounting = Array.isArray(widgetMounting)\n    ? widgetMounting.map(({ mountingPointWidgets, ...restMounting }) => ({\n        ...restMounting,\n        ...(Array.isArray(mountingPointWidgets)\n          ? {\n              mountingPointWidgets: mountingPointWidgets.map(({ checks, ...restWidget }) => ({\n                ...restWidget,\n                tests: Array.isArray(checks)\n                  ? checks.map(({ checkType, ...restCheck }) => ({\n                      ...restCheck,\n                      testType: checkType,\n                    }))\n                  : [],\n              })),\n            }\n          : {}),\n      }))\n    : [];\n\n  const normalizedConfig: Record<string, unknown> = {\n    ...rest,\n    ...(variantTests ? { variantTests } : {}),\n    ...(normalizedWidgetMounting ? { widgetMounting: normalizedWidgetMounting } : {}),\n  };\n\n  const variantId = normalizedConfig.variantId as string;\n  const variantType = normalizedConfig.variantType as string;\n\n  if (typeof variantId !== 'string' || !variantId) {\n    throw new Error(`Missing or invalid variantId for pageVariant`);\n  }\n\n  if (typeof variantType !== 'string' || !variantType) {\n    throw new Error(`Missing or invalid variantType for pageVariant '${variantId}'`);\n  }\n\n  if (!Array.isArray(variantTests)) {\n    throw new Error(\n      `Missing or invalid variantTests for pageVariant '${variantId}'. Must be an array`,\n    );\n  }\n\n  for (const test of variantTests) {\n    if (!test.testType || typeof test.testType !== 'string') {\n      throw new Error(`Invalid variantTest.testType for pageVariant '${variantId}'`);\n    }\n    if (!Object.values(PageVariantTestType).includes(test.testType as PageVariantTestType)) {\n      throw new Error(\n        `Invalid testType '${test.testType}' for pageVariant '${variantId}'. Valid types: ${Object.values(\n          PageVariantTestType,\n        ).join(', ')}`,\n      );\n    }\n  }\n\n  if (!Array.isArray(normalizedWidgetMounting)) {\n    throw new Error(\n      `Missing or invalid widgetMounting for pageVariant '${variantId}'. Must be an array`,\n    );\n  }\n\n  for (const mounting of normalizedWidgetMounting) {\n    if (typeof mounting.mountingConfigId !== 'string' || !mounting.mountingConfigId) {\n      throw new Error(`Invalid mountingConfigId in widgetMounting for pageVariant '${variantId}'`);\n    }\n\n    if (mounting.widgetConfigId && typeof mounting.widgetConfigId !== 'string') {\n      throw new Error(`Invalid widgetConfigId in widgetMounting for pageVariant '${variantId}'`);\n    }\n\n    if (mounting.mountingPointWidgets) {\n      for (const widget of mounting.mountingPointWidgets) {\n        if (typeof widget.widgetConfigId !== 'string' || !widget.widgetConfigId) {\n          throw new Error(\n            `Invalid widgetConfigId in mountingPointWidgets for pageVariant '${variantId}'`,\n          );\n        }\n\n        if (!Array.isArray(widget.tests)) {\n          throw new Error(\n            `Invalid or missing tests in mountingPointWidgets for pageVariant '${variantId}'`,\n          );\n        }\n      }\n    }\n  }\n\n  if (variantType === 'plp') {\n    if (typeof normalizedConfig.plpIdExtractor !== 'string' || !normalizedConfig.plpIdExtractor) {\n      throw new Error(`Missing or invalid plpIdExtractor for PLP pageVariant '${variantId}'`);\n    }\n  }\n\n  if (variantType === 'pdp') {\n    if (\n      typeof normalizedConfig.productIdExtractor !== 'string' ||\n      !normalizedConfig.productIdExtractor\n    ) {\n      throw new Error(`Missing or invalid productIdExtractor for PDP pageVariant '${variantId}'`);\n    }\n    if (\n      normalizedConfig.parentProductIdExtractor &&\n      typeof normalizedConfig.parentProductIdExtractor !== 'string'\n    ) {\n      throw new Error(\n        `Invalid parentProductIdExtractor for PDP pageVariant '${variantId}'. Must be string if provided`,\n      );\n    }\n  }\n\n  return normalizedConfig as PageVariantConfig;\n};\n\n// Helper function to validate and transform MountingConfigQueryData to WidgetMountingConfig\nexport const validateAndTransformMountingConfig = (\n  config: Record<string, unknown>,\n  configKey: string,\n): WidgetMountingConfig => {\n  // RENAMING LOGIC: Convert backend \"Check\" terminology to frontend \"Test\" terminology\n  const normalizedConfig = { ...config };\n\n  // Convert checkId to testId for frontend compatibility (data is already camelCase)\n  if (normalizedConfig.checkId && !normalizedConfig.testId) {\n    normalizedConfig.testId = normalizedConfig.checkId;\n    delete normalizedConfig.checkId;\n  }\n\n  // Required fields - these must be present and valid\n  if (typeof normalizedConfig.mountingConfigId !== 'string' || !normalizedConfig.mountingConfigId) {\n    throw new Error(`Missing or invalid mountingConfigId for config '${configKey}'`);\n  }\n  if (typeof normalizedConfig.containerId !== 'string' || !normalizedConfig.containerId) {\n    throw new Error(`Missing or invalid containerId for config '${configKey}'`);\n  }\n  if (typeof normalizedConfig.testId !== 'string' || !normalizedConfig.testId) {\n    throw new Error(`Missing or invalid testId for config '${configKey}'`);\n  }\n\n  // Required insertionPoint\n  if (\n    !normalizedConfig.insertionPoint ||\n    typeof normalizedConfig.insertionPoint !== 'object' ||\n    Array.isArray(normalizedConfig.insertionPoint)\n  ) {\n    throw new Error(`Missing or invalid insertionPoint for config '${configKey}'`);\n  }\n\n  const insertionPoint = normalizedConfig.insertionPoint as Record<string, unknown>;\n\n  // Validate insertionPoint required fields\n  if (typeof insertionPoint.selector !== 'string' || !insertionPoint.selector) {\n    throw new Error(`Missing or invalid insertionPoint.selector for config '${configKey}'`);\n  }\n  if (typeof insertionPoint.insertionType !== 'string' || !insertionPoint.insertionType) {\n    throw new Error(`Missing or invalid insertionPoint.insertionType for config '${configKey}'`);\n  }\n\n  // Validate insertionType is a valid DOMInsertionType\n  if (!Object.values(DOMInsertionType).includes(insertionPoint.insertionType as DOMInsertionType)) {\n    throw new Error(\n      `Invalid insertionPoint.insertionType '${insertionPoint.insertionType}' for config '${configKey}'. Valid types: ${Object.values(DOMInsertionType).join(', ')}`,\n    );\n  }\n\n  // Validate optional insertionPoint fields\n  if (insertionPoint.selectionIndex != null && typeof insertionPoint.selectionIndex !== 'number') {\n    throw new Error(\n      `Invalid insertionPoint.selectionIndex for config '${configKey}'. Must be a number or null/undefined`,\n    );\n  }\n\n  // Validate optional parentInsertionPoint if present\n  let parentInsertionPoint;\n  if (normalizedConfig.parentInsertionPoint) {\n    if (\n      typeof normalizedConfig.parentInsertionPoint !== 'object' ||\n      Array.isArray(normalizedConfig.parentInsertionPoint)\n    ) {\n      throw new Error(`Invalid parentInsertionPoint for config '${configKey}'. Must be an object`);\n    }\n\n    const parentPoint = normalizedConfig.parentInsertionPoint as Record<string, unknown>;\n    if (typeof parentPoint.selector !== 'string' || !parentPoint.selector) {\n      throw new Error(`Missing or invalid parentInsertionPoint.selector for config '${configKey}'`);\n    }\n    if (typeof parentPoint.insertionType !== 'string' || !parentPoint.insertionType) {\n      throw new Error(\n        `Missing or invalid parentInsertionPoint.insertionType for config '${configKey}'`,\n      );\n    }\n\n    if (!Object.values(DOMInsertionType).includes(parentPoint.insertionType as DOMInsertionType)) {\n      throw new Error(\n        `Invalid parentInsertionPoint.insertionType '${parentPoint.insertionType}' for config '${configKey}'. Valid types: ${Object.values(DOMInsertionType).join(', ')}`,\n      );\n    }\n\n    if (parentPoint.selectionIndex != null && typeof parentPoint.selectionIndex !== 'number') {\n      throw new Error(\n        `Invalid parentInsertionPoint.selectionIndex for config '${configKey}'. Must be a number or null/undefined`,\n      );\n    }\n\n    parentInsertionPoint = {\n      selector: parentPoint.selector,\n      insertionType: parentPoint.insertionType as DOMInsertionType,\n      selectionIndex: parentPoint.selectionIndex as number | undefined,\n    };\n  }\n\n  // Validate optional wrappingElement if present\n  let wrappingElement;\n  if (normalizedConfig.wrappingElement) {\n    if (\n      typeof normalizedConfig.wrappingElement !== 'object' ||\n      Array.isArray(normalizedConfig.wrappingElement)\n    ) {\n      throw new Error(`Invalid wrappingElement for config '${configKey}'. Must be an object`);\n    }\n\n    const wrapping = normalizedConfig.wrappingElement as Record<string, unknown>;\n    if (typeof wrapping.className !== 'string' || !wrapping.className) {\n      throw new Error(`Missing or invalid wrappingElement.className for config '${configKey}'`);\n    }\n    if (typeof wrapping.element !== 'string' || !wrapping.element) {\n      throw new Error(`Missing or invalid wrappingElement.element for config '${configKey}'`);\n    }\n    if (typeof wrapping.insertionType !== 'string' || !wrapping.insertionType) {\n      throw new Error(`Missing or invalid wrappingElement.insertionType for config '${configKey}'`);\n    }\n\n    if (!Object.values(DOMInsertionType).includes(wrapping.insertionType as DOMInsertionType)) {\n      throw new Error(\n        `Invalid wrappingElement.insertionType '${wrapping.insertionType}' for config '${configKey}'. Valid types: ${Object.values(DOMInsertionType).join(', ')}`,\n      );\n    }\n\n    wrappingElement = {\n      className: wrapping.className,\n      element: wrapping.element,\n      insertionType: wrapping.insertionType as DOMInsertionType,\n    };\n  }\n\n  // Validate optional fields\n  if (\n    normalizedConfig.divCheckSelector != null &&\n    typeof normalizedConfig.divCheckSelector !== 'string'\n  ) {\n    throw new Error(\n      `Invalid divCheckSelector for config '${configKey}'. Must be a string or null/undefined`,\n    );\n  }\n  if (normalizedConfig.className != null && typeof normalizedConfig.className !== 'string') {\n    throw new Error(\n      `Invalid className for config '${configKey}'. Must be a string or null/undefined`,\n    );\n  }\n  if (\n    normalizedConfig.suppressionSelector != null &&\n    typeof normalizedConfig.suppressionSelector !== 'string'\n  ) {\n    throw new Error(\n      `Invalid suppressionSelector for config '${configKey}'. Must be a string or null/undefined`,\n    );\n  }\n  if (\n    normalizedConfig.dataAttributes != null &&\n    (typeof normalizedConfig.dataAttributes !== 'object' ||\n      Array.isArray(normalizedConfig.dataAttributes))\n  ) {\n    throw new Error(\n      `Invalid dataAttributes for config '${configKey}'. Must be an object or null/undefined`,\n    );\n  }\n  if (\n    normalizedConfig.style != null &&\n    (typeof normalizedConfig.style !== 'object' || Array.isArray(normalizedConfig.style))\n  ) {\n    throw new Error(`Invalid style for config '${configKey}'. Must be an object or null/undefined`);\n  }\n\n  // Validate gridInsertionType if present\n  let gridInsertionType;\n  if (normalizedConfig.gridInsertionType) {\n    if (\n      typeof normalizedConfig.gridInsertionType !== 'string' ||\n      !normalizedConfig.gridInsertionType\n    ) {\n      throw new Error(`Invalid gridInsertionType for config '${configKey}'. Must be a string`);\n    }\n\n    if (\n      !Object.values(GridInsertionType).includes(\n        normalizedConfig.gridInsertionType as GridInsertionType,\n      )\n    ) {\n      throw new Error(\n        `Invalid gridInsertionType '${normalizedConfig.gridInsertionType}' for config '${configKey}'. Valid types: ${Object.values(GridInsertionType).join(', ')}`,\n      );\n    }\n    gridInsertionType = normalizedConfig.gridInsertionType as GridInsertionType;\n  }\n\n  // Build the return object, only including optional fields if they have values\n  const result: WidgetMountingConfig = {\n    mountingConfigId: normalizedConfig.mountingConfigId,\n    containerId: normalizedConfig.containerId,\n    testId: normalizedConfig.testId,\n    insertionPoint: {\n      selector: insertionPoint.selector,\n      insertionType: insertionPoint.insertionType as DOMInsertionType,\n      ...(insertionPoint.selectionIndex != null && {\n        selectionIndex: insertionPoint.selectionIndex,\n      }),\n    },\n  };\n\n  // Only add optional fields if they have values\n  if (parentInsertionPoint) {\n    result.parentInsertionPoint = parentInsertionPoint;\n  }\n  if (gridInsertionType) {\n    result.gridInsertionType = gridInsertionType;\n  }\n  if (wrappingElement) {\n    result.wrappingElement = wrappingElement;\n  }\n  if (normalizedConfig.divCheckSelector) {\n    result.divCheckSelector = normalizedConfig.divCheckSelector as string;\n  }\n  if (normalizedConfig.className) {\n    result.className = normalizedConfig.className as string;\n  }\n  if (normalizedConfig.suppressionSelector) {\n    result.suppressionSelector = normalizedConfig.suppressionSelector;\n  }\n  if (normalizedConfig.dataAttributes) {\n    result.dataAttributes = normalizedConfig.dataAttributes as Record<string, string>;\n  }\n  if (normalizedConfig.style) {\n    result.style = normalizedConfig.style as Partial<CSSStyleDeclaration>;\n  }\n\n  return result;\n};\n\n// Helper function to validate and transform WidgetConfigQueryData to WidgetConfig\nexport const validateAndTransformWidgetConfig = (\n  config: Record<string, unknown>,\n  configKey: string,\n): WidgetConfig => {\n  const normalizedConfig = transformSnakeToCamel(config) as Record<string, unknown>;\n\n  if (typeof normalizedConfig.widgetConfigId !== 'string' || !normalizedConfig.widgetConfigId) {\n    throw new Error(`Missing or invalid widgetConfigId for widget config '${configKey}'`);\n  }\n  if (typeof normalizedConfig.type !== 'string' || !normalizedConfig.type) {\n    throw new Error(`Missing or invalid type for widget config '${configKey}'`);\n  }\n\n  if (normalizedConfig.contentId != null && typeof normalizedConfig.contentId !== 'string') {\n    throw new Error(\n      `Invalid contentId for widget config '${configKey}'. Must be a string or null/undefined`,\n    );\n  }\n\n  // Note: Widget configs are complex unions with type-specific properties.\n\n  // Return the normalized config as WidgetConfig\n  // Use intermediate 'unknown' cast for complex union types\n  return normalizedConfig as unknown as WidgetConfig;\n};\n\nexport const validateGraphQLFrontendConfig = (data: unknown): FrontendConfig | undefined => {\n  if (data === null || data === undefined) {\n    return undefined;\n  }\n\n  if (typeof data !== 'object' || Array.isArray(data)) {\n    Logger.logWarn('Invalid GraphQL frontend config data: not an object', undefined, { data });\n    return undefined;\n  }\n\n  const obj = data as Record<string, unknown>;\n\n  // Validate merchant_override_css if present\n  if (\n    'merchant_override_css' in obj &&\n    typeof obj.merchant_override_css !== 'string' &&\n    obj.merchant_override_css !== null\n  ) {\n    Logger.logWarn(\n      'Invalid GraphQL frontend config data: merchant_override_css must be a string or null',\n      undefined,\n      { data },\n    );\n    return undefined;\n  }\n\n  // Validate page_variants if present\n  if ('page_variants' in obj) {\n    if (\n      obj.page_variants !== undefined &&\n      obj.page_variants !== null &&\n      !Array.isArray(obj.page_variants)\n    ) {\n      Logger.logWarn(\n        'Invalid GraphQL frontend config data: page_variants must be an array or null/undefined',\n        undefined,\n        { data },\n      );\n      return undefined;\n    }\n  }\n\n  // Validate mounting_configs if present\n  if ('mounting_configs' in obj) {\n    if (\n      obj.mounting_configs !== undefined &&\n      obj.mounting_configs !== null &&\n      !Array.isArray(obj.mounting_configs)\n    ) {\n      Logger.logWarn(\n        'Invalid GraphQL frontend config data: mounting_configs must be an array or null/undefined',\n        undefined,\n        { data },\n      );\n      return undefined;\n    }\n  }\n\n  // Validate widget_configs if present\n  if ('widget_configs' in obj) {\n    if (\n      obj.widget_configs !== undefined &&\n      obj.widget_configs !== null &&\n      !Array.isArray(obj.widget_configs)\n    ) {\n      Logger.logWarn(\n        'Invalid GraphQL frontend config data: widget_configs must be an array or null/undefined',\n        undefined,\n        { data },\n      );\n      return undefined;\n    }\n  }\n\n  // Validate ui_configs if present\n  if ('ui_configs' in obj && typeof obj.ui_configs !== 'object' && obj.ui_configs !== null) {\n    Logger.logWarn(\n      'Invalid GraphQL frontend config data: ui_configs must be an object or null/undefined',\n      undefined,\n      { data },\n    );\n    return undefined;\n  }\n\n  try {\n    // Transform the data to camelCase\n    const transformedData = transformSnakeToCamel(obj) as Record<string, unknown>;\n\n    // Convert page_variants from array to validated array if present\n    if (transformedData.pageVariants && Array.isArray(transformedData.pageVariants)) {\n      const pageVariantsArray = transformedData.pageVariants;\n      const validatedPageVariants: PageVariantConfig[] = [];\n\n      for (const variant of pageVariantsArray) {\n        if (variant && typeof variant === 'object' && typeof variant.variantId === 'string') {\n          try {\n            const validatedVariant = validateAndTransformPageVariants(variant);\n            validatedPageVariants.push(validatedVariant);\n          } catch (error) {\n            Logger.logWarn('Invalid page variant, skipping', error, {\n              variantId: variant.variantId,\n              variant,\n            });\n            // Continue processing other variants\n          }\n        } else {\n          Logger.logWarn('Invalid page variant structure, skipping', undefined, { variant });\n        }\n      }\n\n      transformedData.pageVariants = validatedPageVariants;\n    }\n\n    // Convert mounting_configs from array to Record if present\n    if (transformedData.mountingConfigs && Array.isArray(transformedData.mountingConfigs)) {\n      const mountingConfigsArray = transformedData.mountingConfigs as Array<{\n        key: string;\n        config: unknown;\n      }>;\n      const mountingConfigsRecord: Record<string, WidgetMountingConfig> = {};\n\n      for (const item of mountingConfigsArray) {\n        if (\n          item &&\n          typeof item.key === 'string' &&\n          item.config &&\n          typeof item.config === 'object'\n        ) {\n          try {\n            // Validate and transform the config structure\n            const config = item.config as Record<string, unknown>;\n            const validatedConfig = validateAndTransformMountingConfig(config, item.key);\n            mountingConfigsRecord[item.key] = validatedConfig;\n          } catch (error) {\n            Logger.logWarn('Invalid mounting config, skipping', error, {\n              configKey: item.key,\n              config: item.config,\n            });\n            // Continue processing other configs\n          }\n        } else {\n          Logger.logWarn('Invalid mounting config item structure, skipping', undefined, { item });\n        }\n      }\n\n      transformedData.mountingConfigs = mountingConfigsRecord;\n    }\n\n    // Convert widget_configs from array to Record if present\n    if (transformedData.widgetConfigs && Array.isArray(transformedData.widgetConfigs)) {\n      const widgetConfigsArray = transformedData.widgetConfigs as Array<{\n        key: string;\n        config: unknown;\n      }>;\n      const widgetConfigsRecord: Record<string, unknown> = {};\n\n      for (const item of widgetConfigsArray) {\n        if (\n          item &&\n          typeof item.key === 'string' &&\n          item.config &&\n          typeof item.config === 'object'\n        ) {\n          try {\n            // Validate and transform widget config using the dedicated validation function\n            const config = item.config as Record<string, unknown>;\n            const validatedConfig = validateAndTransformWidgetConfig(config, item.key);\n            widgetConfigsRecord[item.key] = validatedConfig;\n          } catch (error) {\n            Logger.logWarn('Invalid widget config, skipping', error, {\n              configKey: item.key,\n              config: item.config,\n            });\n            // Continue processing other configs\n          }\n        } else {\n          Logger.logWarn('Invalid widget config item structure, skipping', undefined, { item });\n        }\n      }\n\n      transformedData.widgetConfigs = widgetConfigsRecord;\n    }\n\n    return transformedData as FrontendConfig;\n  } catch (error) {\n    Logger.logWarn('Failed to validate and transform GraphQL frontend config data', error, {\n      data,\n    });\n    return undefined;\n  }\n};\n","export const validateGraphQLOrgId = (data: unknown): string | undefined => {\n  if (typeof data !== 'string' || data === '') {\n    return undefined;\n  }\n\n  return data;\n};\n","import { isMobilePLPChatPlacementParameter } from '../guards/isMobilePLPChatPlacementParameter';\nimport { MobilePLPChatPlacementParameter } from '../mobilePLPChatPlacementParameter';\n\nexport const validateMobilePLPChatPlacementParameter = (\n  value: unknown,\n): MobilePLPChatPlacementParameter | undefined => {\n  if (!isMobilePLPChatPlacementParameter(value)) {\n    return undefined;\n  }\n\n  return {\n    rowIndex: value.row_index,\n  };\n};\n","import { OrganizationConfig } from 'src/application/models/api/organizationConfig';\nimport { isApiOrganizationConfig } from 'src/application/models/guards/api/isApiOrganizationConfig';\n\nexport const validateOrganizationConfig = (data: unknown): OrganizationConfig | undefined => {\n  if (!isApiOrganizationConfig(data)) {\n    return undefined;\n  }\n\n  return {\n    id: data.id,\n    createdAt: data.created_at.toISOString(),\n    namespace: data.namespace,\n    organizationId: data.organization_id,\n    isLatest: data.is_latest,\n    version: data.version,\n    updatedAt: data.updated_at.toISOString(),\n    config: {\n      amplitude: data.config.amplitude\n        ? {\n            sessionReplayEnabled: data.config.amplitude.session_replay_enabled,\n            sessionReplaySampleRate: data.config.amplitude.session_replay_sample_rate,\n            trackingEnabled: data.config.amplitude.tracking_enabled,\n          }\n        : undefined,\n      customerService: data.config.customer_service\n        ? {\n            provider: data.config.customer_service.provider,\n          }\n        : undefined,\n      googleAnalytics: data.config.google_analytics\n        ? {\n            measurementId: data.config.google_analytics.measurement_id,\n          }\n        : undefined,\n    },\n  };\n};\n","import { isApiOrgConfigResults } from 'src/application/models/guards/api/isApiOrgConfigResults';\nimport { OrgConfig } from 'src/application/models/api/orgConfigResults';\nimport { validateOrganizationConfig } from 'src/application/models/validators/validateOrganizationConfig';\nimport { OrganizationConfig } from 'src/application/models/api/organizationConfig';\n\n/**\n *\n * @param data\n * @returns\n */\nexport const validateOrgConfigResults = (data: unknown): OrgConfig | undefined => {\n  if (!isApiOrgConfigResults(data)) {\n    return undefined;\n  }\n\n  return {\n    configs: data.configs\n      .map((config) => validateOrganizationConfig(config))\n      .filter((config): config is OrganizationConfig => config != null),\n    experiments: data.experiments.map((experiment) => ({\n      group: experiment.group,\n      groupName: experiment.group_name,\n      name: experiment.name,\n      ruleId: experiment.rule_id,\n      // TODO this needs to be strongly typed but we're not running any experiments at the moment\n      value: experiment.value as Record<string, unknown>,\n    })),\n    gates: data.gates.map((gate) => ({\n      groupName: gate.group_name,\n      name: gate.name,\n      ruleId: gate.rule_id,\n      value: gate.value,\n    })),\n    org: {\n      org: {\n        id: data.org.org.id,\n        displayName: data.org.org.display_name,\n        domain: data.org.org.domain,\n        shortName: data.org.org.short_name,\n        status: data.org.org.status,\n        createdAt: data.org.org.created_at?.toISOString(),\n        updatedAt: data.org.org.updated_at?.toISOString(),\n      },\n      settings: {},\n    },\n  };\n};\n","import { ResponseCategory } from '@spiffy-ai/commerce-api-client';\nimport { Response, ReviewRichInformation } from 'src/application/models/index';\nimport { ApiReviewRichInformation } from 'src/application/models/api/responseGenerics';\nimport { isApiPageResponseAttributes } from 'src/application/models/guards/api/isApiPageResponseAttributes';\nimport { isApiProductResponseAttributes } from 'src/application/models/guards/api/isApiProductResponseAttributes';\nimport { isApiResponse } from 'src/application/models/guards/api/isApiResponse';\nimport { isApiReviewResponseAttributes } from 'src/application/models/guards/api/isApiReviewResponseAttributes';\nimport { isApiTextResponseAttributes } from 'src/application/models/guards/api/isApiTextResponseAttributes';\nimport { isApiProductSearchResponseAttributes } from 'src/application/models/guards/api/isApiProductSearchAttributes';\nimport { isApiFormResponseAttributes } from 'src/application/models/guards/api/isApiFormResponse';\nimport { isApiOrderResponseAttributes } from 'src/application/models/guards/api/isApiOrderResponseAttributes';\nimport { stringToFulfillmentDisplayStatusEnumValue } from 'src/application/models/utils/stringToFulfillmentDisplayStatusEnumValue';\nimport { isApiProductSearchFilterResponseAttributes } from 'src/application/models/guards/api/isApiProductSearchFilterAttributes';\n\nconst richInformationFromCommerceRichInformation = (\n  data: ApiReviewRichInformation,\n): ReviewRichInformation => ({\n  cons: data.cons,\n  pros: data.pros,\n  reviewDate: data.review_date,\n  reviewerTitle: data.reviewer_title,\n  productFamiliarity: data.product_familiarity,\n});\n\nexport const validateResponse = (data: unknown): Response | undefined => {\n  if (!isApiResponse(data)) {\n    return undefined;\n  }\n\n  if (data.category === ResponseCategory.Text && isApiTextResponseAttributes(data.attributes)) {\n    return {\n      id: data.id,\n      createdAt: data.created_at,\n      category: ResponseCategory.Text,\n      attributes: {\n        content: data.attributes.content,\n      },\n    };\n  }\n\n  if (\n    data.category === ResponseCategory.Product &&\n    isApiProductResponseAttributes(data.attributes)\n  ) {\n    return {\n      id: data.id,\n      createdAt: data.created_at,\n      category: ResponseCategory.Product,\n      attributes: {\n        id: data.attributes.id,\n        description: data.attributes.description,\n        imageUrl: data.attributes.image_url,\n        imageUrls: data.attributes.image_urls,\n        title: data.attributes.title,\n        url: data.attributes.url,\n        originalPrice: data.attributes.original_price,\n        salePrice: data.attributes.sale_price,\n        averageRating: data.attributes.average_rating,\n        numberReviews: data.attributes.number_reviews,\n        metadata: data.attributes.metadata,\n        isForGrid: data.attributes.is_for_grid,\n        colors: data.attributes.colors,\n        sizes: data.attributes.sizes,\n        filters: data.attributes.filters,\n      },\n    };\n  }\n\n  if (data.category === ResponseCategory.Review && isApiReviewResponseAttributes(data.attributes)) {\n    return {\n      id: data.id,\n      createdAt: data.created_at,\n      category: ResponseCategory.Review,\n      attributes: {\n        id: data.attributes.id,\n        productId: data.attributes.product_id,\n        title: data.attributes.title,\n        reviewer: data.attributes.reviewer,\n        review: data.attributes.review,\n        stars: data.attributes.stars,\n        richInformation: data.attributes.rich_information\n          ? richInformationFromCommerceRichInformation(data.attributes.rich_information)\n          : undefined,\n      },\n    };\n  }\n\n  if (data.category === ResponseCategory.Separator) {\n    return {\n      id: data.id,\n      createdAt: data.created_at,\n      category: ResponseCategory.Separator,\n    };\n  }\n\n  if (data.category === ResponseCategory.Page && isApiPageResponseAttributes(data.attributes)) {\n    return {\n      id: data.id,\n      createdAt: data.created_at,\n      category: ResponseCategory.Page,\n      attributes: {\n        id: data.attributes.id,\n        title: data.attributes.title,\n        description: data.attributes.description,\n        url: data.attributes.url,\n      },\n    };\n  }\n\n  if (data.category === ResponseCategory.Form && isApiFormResponseAttributes(data.attributes)) {\n    return {\n      id: data.id,\n      createdAt: data.created_at,\n      category: ResponseCategory.Form,\n      attributes: {\n        formCategory: data.attributes.form_category\n          ? {\n              formType: data.attributes.form_category.form_type,\n            }\n          : undefined,\n        schema: {\n          properties: data.attributes.schema.properties,\n          required: data.attributes.schema.required.map(String),\n        },\n      },\n    };\n  }\n\n  if (\n    data.category === ResponseCategory.ProductSearch &&\n    isApiProductSearchResponseAttributes(data.attributes)\n  ) {\n    return {\n      id: data.id,\n      createdAt: data.created_at,\n      category: ResponseCategory.ProductSearch,\n      attributes: {\n        generatedQuery: data.attributes.generated_query,\n        productCount: data.attributes.product_count,\n      },\n    };\n  }\n\n  if (\n    data.category === ResponseCategory.ProductSearchFilter &&\n    isApiProductSearchFilterResponseAttributes(data.attributes)\n  ) {\n    return {\n      id: data.id,\n      createdAt: data.created_at,\n      category: ResponseCategory.ProductSearchFilter,\n      attributes: {\n        filterName: data.attributes.filter_name,\n      },\n    };\n  }\n\n  if (data.category === ResponseCategory.Order && isApiOrderResponseAttributes(data.attributes)) {\n    return {\n      id: data.id,\n      createdAt: data.created_at,\n      category: ResponseCategory.Order,\n      attributes: {\n        orderId: data.attributes.order_id,\n        orderNumber: data.attributes.order_number,\n        createdAt: data.attributes.created_at,\n        latestEventDate: data.attributes.latest_event_date,\n        lineItems: data.attributes.line_items.map((item) => ({\n          itemTitle: item.item_title,\n          itemPrice: item.item_price,\n          itemQuantity: item.item_quantity,\n          orderItemId: item.order_item_id,\n          image: item.image ?? undefined,\n          inTransitAt: item.in_transit_at ?? undefined,\n          deliveredAt: item.delivered_at ?? undefined,\n          estimatedDeliveryAt: item.estimated_delivery_at ?? undefined,\n          fulfillmentDisplayStatus: item.fulfillment_display_status\n            ? stringToFulfillmentDisplayStatusEnumValue(item.fulfillment_display_status)\n            : undefined,\n          trackingUrl: item.tracking_url ?? undefined,\n        })),\n      },\n    };\n  }\n\n  return undefined;\n};\n","import { isSuggestion } from '../guards/api/isApiSuggestion';\nimport { Suggestion } from '../api/suggestion';\n\nexport const validateSuggestion = (data: unknown): Suggestion | undefined => {\n  if (!isSuggestion(data)) {\n    return undefined;\n  }\n\n  return {\n    id: data.id,\n    category: data.category,\n    content: data.content,\n    createdAt: data.created_at,\n    isAnswer: data.is_answer,\n  };\n};\n","import { UserEventCategory } from '@spiffy-ai/commerce-api-client';\nimport { isApiUserEvent } from 'src/application/models/guards/api/isApiUserEvent';\nimport { UserEvent } from 'src/application/models/index';\nimport { isApiPDPAttributes } from 'src/application/models/guards/api/isApiPDPEventAttributes';\nimport { isApiQueryTypedAttributes } from 'src/application/models/guards/api/isApiQueryTypedEventAttributes';\nimport { isApiSearchAttributes } from 'src/application/models/guards/api/isApiSearchEventAttributes';\nimport { isApiSuggestionClickedAttributes } from 'src/application/models/guards/api/isApiSuggestionClickedEventAttributes';\nimport {\n  isApiPLPEventAttributes,\n  isApiPLPIdAttribute,\n} from 'src/application/models/guards/api/isApiPLPEventAttributes';\nimport { isApiFormSubmittedResponseAttributes } from 'src/application/models/guards/api/isApiFormSubmittedResponseAttributes';\n\nexport const validateUserEvent = (data: unknown): UserEvent | undefined => {\n  if (!isApiUserEvent(data)) {\n    return undefined;\n  }\n\n  if (data.category === UserEventCategory.PdpVisit && isApiPDPAttributes(data.attributes)) {\n    return {\n      eventId: data.event_id,\n      createdAt: data.created_at,\n      category: UserEventCategory.PdpVisit,\n      attributes: {\n        productId: data.attributes.product_id,\n        parentProductId: data.attributes.parent_product_id,\n        url: data.attributes.url,\n      },\n    };\n  }\n\n  if (\n    data.category === UserEventCategory.QueryTyped &&\n    isApiQueryTypedAttributes(data.attributes)\n  ) {\n    return {\n      eventId: data.event_id,\n      createdAt: data.created_at,\n      category: UserEventCategory.QueryTyped,\n      attributes: {\n        query: data.attributes.query,\n      },\n    };\n  }\n\n  if (data.category === UserEventCategory.Search && isApiSearchAttributes(data.attributes)) {\n    return {\n      eventId: data.event_id,\n      createdAt: data.created_at,\n      category: UserEventCategory.Search,\n      attributes: {\n        searchTerm: data.attributes.search_term,\n        selectedFilters: data.attributes.selected_filters,\n      },\n    };\n  }\n\n  if (\n    data.category === UserEventCategory.SuggestionClicked &&\n    isApiSuggestionClickedAttributes(data.attributes)\n  ) {\n    return {\n      eventId: data.event_id,\n      createdAt: data.created_at,\n      category: UserEventCategory.SuggestionClicked,\n      attributes: {\n        suggestionId: data.attributes.suggestion_id,\n      },\n    };\n  }\n\n  if (data.category === UserEventCategory.PlpVisit && isApiPLPEventAttributes(data.attributes)) {\n    if (isApiPLPIdAttribute(data.attributes)) {\n      return {\n        eventId: data.event_id,\n        createdAt: data.created_at,\n        category: UserEventCategory.PlpVisit,\n        attributes: {\n          category: data.attributes.category,\n          attributes: {\n            id: data.attributes.id,\n          },\n        },\n      };\n    }\n  }\n\n  if (\n    data.category === UserEventCategory.FormSubmitted &&\n    isApiFormSubmittedResponseAttributes(data.attributes)\n  ) {\n    return {\n      eventId: data.event_id,\n      createdAt: data.created_at,\n      category: UserEventCategory.FormSubmitted,\n      attributes: {\n        filledSchema: { ...data.attributes.filled_schema },\n        formResponseId: data.attributes.form_response_id,\n        formType: data.attributes.form_type,\n      },\n    };\n  }\n\n  // we're not using app_unloaded at the moment so return the app_loaded event as default\n  return {\n    eventId: data.event_id,\n    createdAt: data.created_at,\n    category: UserEventCategory.AppLoaded,\n  };\n};\n"],"mappings":"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"}