@envive-ai/react-hooks 0.1.5 → 0.1.7

package/dist/index-Bs0QtkSu.d.ts

@@ -0,0 +1,689 @@
+import { GetMerchantColorsQueryData } from "./index-BS7-_CW4.js";
+import { AcceptableFormFieldType, ApiFormResponseAttributes, ApiPageResponseAttributes, OrderResponseAttributes as OrderResponseAttributes$1, PageResponseAttributes, ProductResponseAttributes, Response as Response$1, ReviewResponseAttributes, SearchProductFilterAttributes, SearchProductResponseAttributes, SearchResponseAttributes, TextResponseAttributes } from "./index-DuyZQOE1.js";
+import { CamelCasedPropertiesDeep, NonRecursiveType, UnknownArray, UpperCaseCharacters, WordSeparators } from "./index-D9VegTU-.js";
+import { ColorMapping, FrontendConfig, OrgConfig$1 as OrgConfig, OrganizationConfig as OrganizationConfig$1, PageVariantConfig, WidgetConfig, WidgetMountingConfig } from "./frontendConfig-DrvrQSm8.js";
+import { VariantInfo } from "./index-DNUKSg6R.js";
+import { Context, CustServiceAttachment, FormSubmittedAttributes, FormType, FulfillmentDisplayStatus, GenerationParams, OrderItemInfo, OrderResponseAttributes, OrganizationConfig, OrganizationSettings, PDPAttributes, PLPAttributes, PLPIdAttributes, PageVisitCategory, ProductSearchFilterResponseAttributes, QueryTypedAttributes, SearchAttributes, StatsigExperiment, StatsigFeatureGate, Suggestion, SuggestionClickedAttributes, UserEvent, UserEventCategory } from "@spiffy-ai/commerce-api-client";
+
+//#region src/application/models/cachedValue.d.ts
+interface CachedValue {
+  value: unknown;
+  expiry: number;
+}
+//#endregion
+//#region src/application/models/clientDetails.d.ts
+interface ClientDetails {
+  os?: string;
+  osVersion?: string;
+  deviceBrand?: string;
+  deviceManufacturer?: string;
+  deviceModel?: string;
+  carrier?: string;
+  country?: string;
+  region?: string;
+  browser?: string;
+  browserVersion?: string;
+  browserIpAddress?: string;
+  userAgent?: string;
+}
+//#endregion
+//#region src/application/models/conversationalSearchIds.d.ts
+type ConversationalSearchIds = {
+  conversationalSearchEntrypointId?: string;
+  conversationalSearchInputId?: string;
+  conversationalSearchModalId?: string;
+};
+//#endregion
+//#region src/application/models/dataLayer.d.ts
+/**
+ * Base interface for common properties across all ecommerce events
+ */
+interface BaseEcommerceEvent {
+  event: string;
+  ecommerce: UAEcommerceData | GA4EcommerceData;
+}
+/**
+ * Legacy universal analytics data. The actual payload contains more fields, but we
+ * only need the ones listed below.
+ */
+interface UAEcommerceData {
+  add: {
+    products: {
+      name: string;
+      category: string;
+      price: string;
+      quantity: string;
+    }[];
+    currencyCode: string;
+  };
+}
+/**
+ * Google Analytics 4 data. The actual payload contains more fields, but we
+ * only need the ones listed below.
+ */
+interface GA4EcommerceData {
+  currency: string;
+  items: {
+    item_name: string;
+    item_category: string;
+    price: number;
+    quantity: number;
+  }[];
+}
+interface UAEcommerceEvent extends BaseEcommerceEvent {
+  ecommerce: UAEcommerceData;
+}
+interface GA4EcommerceEvent extends BaseEcommerceEvent {
+  ecommerce: GA4EcommerceData;
+}
+//#endregion
+//#region src/application/models/events.d.ts
+declare enum SpiffyEventName {
+  WidgetOpen = "spiffy:widgetopen",
+  WidgetClose = "spiffy:widgetclose",
+}
+//#endregion
+//#region src/application/models/googleAnalyticsEvents.d.ts
+declare enum GoogleAnalyticsEvents {
+  ADD_TO_CART_v1 = "add_to_cart",
+  ADD_TO_CART_v2 = "addToCart",
+}
+//#endregion
+//#region src/application/models/message.d.ts
+declare enum MessageRole {
+  User = "user",
+  Assistant = "assistant",
+}
+declare enum MessageType {
+  Text = "text",
+  SuggestionClicked = "suggestion_clicked",
+  Product = "product",
+  ProductSearch = "product_search",
+  Review = "review",
+  QueryTyped = "query_typed",
+  Separator = "separator",
+  Page = "page",
+  Search = "search",
+  Attachment = "attachment",
+  CXAgentResponse = "cx_agent_response",
+  Form = "form",
+  Order = "order",
+  ProductSearchFilter = "product_search_filter",
+}
+type Message = {
+  id: string;
+  role: MessageRole;
+  createdAt: string;
+} & (TextMessageMetadata | QueryTypedMetadata | SuggestionMessageMetadata | ProductMessageMetadata | ProductSearchMessageMetadata | ReviewMessageMetadata | SeparatorMessageMetadata | PageMessageMetadata | SearchMessageMetadata | AttachmentMetadata | CXAgentResponseMetadata | FormMessageMetadata | OrderMessageMetadata | ProductSearchFilterMetadata);
+type AttachmentMetadata = {
+  type: MessageType.Attachment;
+  metadata: {
+    message?: string;
+    attachment: CustServiceAttachment[];
+  };
+};
+type CXAgentResponseMetadata = {
+  type: MessageType.CXAgentResponse;
+  metadata: {
+    message: string;
+    agentName: string;
+  };
+};
+type TextMessageMetadata = {
+  type: MessageType.Text;
+  metadata: TextResponseAttributes['attributes'];
+};
+type QueryTypedMetadata = {
+  type: MessageType.QueryTyped;
+  metadata: TextResponseAttributes['attributes'];
+};
+type SuggestionMessageMetadata = {
+  type: MessageType.SuggestionClicked;
+  metadata: {
+    suggestionId: string;
+    suggestionContent: string;
+  };
+};
+type ProductMessageMetadata = {
+  type: MessageType.Product;
+  metadata: ProductResponseAttributes['attributes'];
+};
+type ProductSearchMessageMetadata = {
+  type: MessageType.ProductSearch;
+  metadata: SearchProductResponseAttributes['attributes'];
+};
+type ReviewMessageMetadata = {
+  type: MessageType.Review;
+  metadata: ReviewResponseAttributes['attributes'];
+};
+type SeparatorMessageMetadata = {
+  type: MessageType.Separator;
+};
+type PageMessageMetadata = {
+  type: MessageType.Page;
+  metadata: PageResponseAttributes['attributes'];
+};
+type SearchMessageMetadata = {
+  type: MessageType.Search;
+  metadata: SearchResponseAttributes['attributes'];
+};
+type ProductSearchFilterMetadata = {
+  type: MessageType.ProductSearchFilter;
+  metadata: SearchProductFilterAttributes['attributes'];
+};
+type FormField = {
+  key: string;
+  title: string;
+  type: AcceptableFormFieldType;
+  required: boolean;
+  format?: 'email';
+  value?: string;
+};
+type FormMessageMetadata = {
+  type: MessageType.Form;
+  metadata: {
+    formType?: FormType;
+    fields: FormField[];
+  };
+};
+type OrderMessageMetadata = {
+  type: MessageType.Order;
+  metadata: OrderResponseAttributes$1['attributes'];
+};
+//#endregion
+//#region src/application/models/mobilePLPChatPlacementParameter.d.ts
+interface MobilePLPChatPlacementParameter {
+  rowIndex: number;
+}
+//#endregion
+//#region src/application/models/orgsEnum.d.ts
+declare const OrgShortName: {
+  readonly Coterie: "coterie";
+  readonly ForLoveAndLemons: "for-love-and-lemons";
+  readonly Greenpan: "greenpan";
+  readonly JordanCraig: "jordan-craig";
+  readonly LarryAndSerges: "larry_and_serges";
+  readonly LeapsAndRebounds: "leaps-and-rebounds";
+  readonly MantraBrand: "mantra-brand";
+  readonly Spanx: "spanx";
+  readonly SpanxStaging: "staging-spanx";
+  readonly Supergoop: "supergoop";
+  readonly UniqueVintage: "unique-vintage";
+  readonly JackArcher: "jack-archer";
+  readonly SkinPerfection: "skin-perfection";
+  readonly LookOptic: "look-optic";
+  readonly FiveCbd: "five-cbd";
+  readonly SnapSupplements: "snap-supplements";
+  readonly Longevityrx: "longevityrx";
+  readonly VenaCbd: "vena-cbd";
+  readonly Medterra: "medterra";
+  readonly Modells: "modells";
+  readonly PressedFloral: "pressed-floral";
+  readonly KindredBravely: "kindred-bravely";
+  readonly WineEnthusiast: "wine-enthusiast";
+  readonly HomegrownCannabis: "homegrown-cannabis";
+  readonly DreamlandBaby: "dreamland-baby";
+  readonly Bandolier: "bandolier";
+  readonly WestonJonBoucher: "weston-jon-boucher";
+  readonly KutFromTheKloth: "kut-from-the-kloth";
+  readonly GrooveLife: "groove-life";
+  readonly Carpe: "carpe";
+  readonly WolfTactical: "wolf-tactical";
+  readonly WolfMattress: "wolfmattress";
+  readonly Default: "default";
+};
+//#endregion
+//#region src/application/models/productExperiment.d.ts
+declare enum ProductExperiment {
+  Default = "default",
+}
+//#endregion
+//#region src/application/models/spanxTakeAQuizCtaParameter.d.ts
+interface SpanxTakeAQuizCtaParameter {
+  text?: string;
+  value?: string;
+}
+//#endregion
+//#region src/application/models/api/context.d.ts
+interface Context$1 extends CamelCasedPropertiesDeep<Context> {}
+//#endregion
+//#region src/application/models/api/generationParams.d.ts
+interface GenerationParams$1 extends CamelCasedPropertiesDeep<GenerationParams> {}
+//#endregion
+//#region src/application/models/api/userEvent.d.ts
+interface PDPAttributes$1 extends CamelCasedPropertiesDeep<PDPAttributes> {}
+interface PLPAttributes$1 extends CamelCasedPropertiesDeep<PLPAttributes> {}
+interface SearchAttributes$1 extends CamelCasedPropertiesDeep<SearchAttributes> {}
+interface QueryTypedAttributes$1 extends CamelCasedPropertiesDeep<QueryTypedAttributes> {}
+interface FormSubmittedAttributes$1 {
+  filledSchema: Record<string, unknown>;
+  formResponseId: string;
+  formType: FormType;
+}
+interface PageVisitAttributes {
+  url: string;
+  pageVisitCategory: PageVisitCategory;
+}
+interface SuggestionClickedAttributes$1 extends CamelCasedPropertiesDeep<SuggestionClickedAttributes> {}
+type UserEventAttributes = PDPAttributes$1 | PLPAttributes$1 | QueryTypedAttributes$1 | SearchAttributes$1 | SuggestionClickedAttributes$1 | PageVisitAttributes;
+interface PDPUserEvent {
+  category: UserEventCategory.PdpVisit | UserEventCategory.AddToCart;
+  attributes: PDPAttributes$1;
+}
+interface PLPUserEvent {
+  category: UserEventCategory.PlpVisit;
+  attributes: PLPAttributes$1;
+}
+interface QueryTypedUserEvent {
+  category: UserEventCategory.QueryTyped;
+  attributes: QueryTypedAttributes$1;
+}
+interface SearchUserEvent {
+  category: UserEventCategory.Search;
+  attributes: SearchAttributes$1;
+}
+interface SuggestionsClickedUserEvent {
+  category: UserEventCategory.SuggestionClicked;
+  attributes: SuggestionClickedAttributes$1;
+}
+interface AppLoadedUserEvent {
+  category: UserEventCategory.AppLoaded;
+}
+interface AppUnloadedEvent {
+  category: UserEventCategory.AppUnloaded;
+}
+interface PageVisitEvent {
+  category: UserEventCategory.PageVisit;
+  attributes: PageVisitAttributes;
+}
+interface FormSubmitted {
+  category: UserEventCategory.FormSubmitted;
+  attributes: FormSubmittedAttributes$1;
+}
+type UserEvent$1 = CamelCasedPropertiesDeep<Pick<UserEvent, 'event_id' | 'category' | 'created_at'>> & (SuggestionsClickedUserEvent | AppLoadedUserEvent | PDPUserEvent | QueryTypedUserEvent | SearchUserEvent | AppUnloadedEvent | PLPUserEvent | PageVisitEvent | FormSubmitted);
+//#endregion
+//#region src/application/models/api/nextMessageRequest.d.ts
+interface NextMessageRequest$1 {
+  id: string;
+  context: Context$1;
+  userEvents?: UserEvent$1[];
+  featureFlags?: Record<string, boolean>;
+  generationParams?: GenerationParams$1;
+}
+//#endregion
+//#region src/application/models/api/suggestion.d.ts
+interface Suggestion$1 extends CamelCasedPropertiesDeep<Suggestion> {}
+//#endregion
+//#region src/application/models/api/supportedEventRequest.d.ts
+interface SupportedEventRequest$1 {
+  id: string;
+  context: Context$1;
+  userEvent: UserEvent$1;
+}
+//#endregion
+//#region src/application/models/graphql/queries/getMerchantOrgIdQuery.d.ts
+declare const getMerchantOrgIdQuery = "\n  query {\n    me {\n      org {\n        id\n      }\n    }\n  }\n";
+//#endregion
+//#region src/application/models/guards/isBaseEcommerceEvent.d.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.
+ */
+declare const isBaseEcommerceEvent: (data: unknown) => data is BaseEcommerceEvent;
+//#endregion
+//#region src/application/models/guards/isGA4EcommerceEvent.d.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.
+ */
+declare const isGA4EcommerceEvent: (data: unknown) => data is GA4EcommerceEvent;
+//#endregion
+//#region src/application/models/guards/isLegacyUAEcommerceEvent.d.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.
+ */
+declare const isLegacyUAEcommerceEvent: (data: unknown) => data is UAEcommerceEvent;
+//#endregion
+//#region src/application/models/guards/isMobilePLPChatPlacementParameter.d.ts
+interface MobilePlpChatPlacementParameter {
+  row_index: number;
+}
+declare const isMobilePLPChatPlacementParameter: (value: unknown) => value is MobilePlpChatPlacementParameter;
+//#endregion
+//#region src/application/models/guards/isSpanxTakeAQuizCtaParameter.d.ts
+declare const isSpanxTakeAQuizCtaParameter: (value: unknown) => value is SpanxTakeAQuizCtaParameter;
+//#endregion
+//#region src/application/models/guards/isVariantInfo.d.ts
+/**
+ * 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.
+ */
+declare const isVariantInfo: (variantInfo: unknown) => variantInfo is VariantInfo;
+//#endregion
+//#region src/application/models/guards/utils.d.ts
+/**
+ * Checks if an object has a property of a specific type
+ *
+ * @param obj - The object to check
+ * @param prop - The property name to check
+ * @param type - The expected type of the property
+ * @param isOptional - Whether the property is optional (defaults to false)
+ *
+ * @returns boolean indicating if the object has the property of the specified type
+ */
+declare const hasPropertyOfType: <T extends object>(obj: unknown, prop: keyof T, type: "string" | "number" | "boolean" | "object" | "array", isOptional?: boolean) => obj is T;
+//#endregion
+//#region src/application/models/guards/api/isApiFormResponse.d.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
+ */
+declare const isApiFormResponseAttributes: (data: unknown) => data is ApiFormResponseAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiFormSubmittedResponseAttributes.d.ts
+declare const isApiFormSubmittedResponseAttributes: (data: unknown) => data is FormSubmittedAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiOrderResponseAttributes.d.ts
+interface ApiOrderItemInfo extends Omit<OrderItemInfo, 'delivered_at' | 'estimated_delivery_at' | 'in_transit_at'> {
+  delivered_at?: string;
+  estimated_delivery_at?: string;
+  in_transit_at?: string;
+}
+interface ApiOrderResponseAttributes extends Omit<OrderResponseAttributes, 'created_at' | 'latest_event_date' | 'line_items'> {
+  created_at: string;
+  latest_event_date: string;
+  line_items: ApiOrderItemInfo[];
+}
+declare const isApiOrderResponseAttributes: (data: unknown) => data is ApiOrderResponseAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiOrganizationConfig.d.ts
+interface ApiOrgAnalyticsConfigAmplitude {
+  session_replay_enabled: boolean;
+  session_replay_sample_rate: number;
+  tracking_enabled: boolean;
+}
+interface ApiOrgAnalyticsConfigCustomerService {
+  provider: string;
+}
+interface ApiOrgAnalyticsConfigGoogleAnalytics {
+  measurement_id: string;
+}
+interface ApiOrgAnalyticsConfig {
+  amplitude?: ApiOrgAnalyticsConfigAmplitude;
+  customer_service?: ApiOrgAnalyticsConfigCustomerService;
+  google_analytics?: ApiOrgAnalyticsConfigGoogleAnalytics;
+}
+interface ApiOrganizationConfig extends OrganizationConfig {
+  config: ApiOrgAnalyticsConfig;
+}
+/**
+ *
+ * @param data
+ * @returns
+ */
+declare const isApiOrganizationConfig: (data: unknown) => data is ApiOrganizationConfig;
+//#endregion
+//#region src/application/models/guards/api/isApiOrgConfigResults.d.ts
+interface ApiOrgConfigResults {
+  configs: ApiOrganizationConfig[];
+  experiments: StatsigExperiment[];
+  gates: StatsigFeatureGate[];
+  org: OrganizationSettings;
+}
+/**
+ *
+ * @param data
+ * @returns
+ */
+declare const isApiOrgConfigResults: (data: unknown) => data is Required<ApiOrgConfigResults>;
+//#endregion
+//#region src/application/models/guards/api/isApiPageResponseAttributes.d.ts
+declare const isApiPageResponseAttributes: (obj: unknown) => obj is ApiPageResponseAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiPLPEventAttributes.d.ts
+declare const isApiPLPIdAttribute: (data: unknown) => data is PLPIdAttributes;
+declare const isApiPLPEventAttributes: (data: unknown) => data is PLPAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiProductSearchFilterAttributes.d.ts
+declare const isApiProductSearchFilterResponseAttributes: (attributes: unknown) => attributes is ProductSearchFilterResponseAttributes;
+//#endregion
+//#region src/application/models/guards/graphQL/isGraphQLColorsConfig.d.ts
+declare const isGraphQLColorsConfig: (data: unknown) => data is GetMerchantColorsQueryData;
+//#endregion
+//#region src/application/models/utilityTypes/delimiterCase.d.ts
+type UpperCaseToLowerCase<T extends string> = T extends Uppercase<T> ? Lowercase<T> : T;
+type SplitIncludingDelimiters_<Source extends string, Delimiter extends string> = Source extends '' ? [] : Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}` ? Source extends `${FirstPart}${infer UsedDelimiter}${SecondPart}` ? UsedDelimiter extends Delimiter ? Source extends `${infer FirstPart}${UsedDelimiter}${infer SecondPart}` ? [...SplitIncludingDelimiters<FirstPart, Delimiter>, UsedDelimiter, ...SplitIncludingDelimiters<SecondPart, Delimiter>] : never : never : never : [Source];
+/**
+ * Unlike a simpler split, this one includes the delimiter splitted on in the resulting array literal. This is to enable splitting on, for example, upper-case characters.
+ *
+ * @category Template literal
+ */
+type SplitIncludingDelimiters<Source extends string, Delimiter extends string> = SplitIncludingDelimiters_<UpperCaseToLowerCase<Source>, Delimiter>;
+/**
+ *Format a specific part of the splitted string literal that `StringArrayToDelimiterCase<>` fuses together, ensuring desired casing.
+ *
+ *@see StringArrayToDelimiterCase
+ */
+type StringPartToDelimiterCase<StringPart extends string, Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> = StringPart extends UsedWordSeparators ? Delimiter : Start extends true ? Lowercase<StringPart> : StringPart extends UsedUpperCaseCharacters ? `${Delimiter}${Lowercase<StringPart>}` : StringPart;
+/**
+ * Takes the result of a splitted string literal and recursively concatenates it together into the desired casing.
+ *
+ * It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensure it's fully encapsulated.
+ *
+ * @see SplitIncludingDelimiters
+ */
+type StringArrayToDelimiterCase<Parts extends readonly any[], Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> = Parts extends [`${infer FirstPart}`, ...infer RemainingParts] ? `${StringPartToDelimiterCase<FirstPart, Start, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}${StringArrayToDelimiterCase<RemainingParts, false, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}` : Parts extends [string] ? string : '';
+/**
+ * Convert a string literal to a custom string delimiter casing.
+ *
+ * This can be useful when, for example, converting a camel-cased object property to an oddly cased one.
+ *
+ * @see KebabCase
+ * @see SnakeCase
+ *
+ * @example
+ * ```
+ * import type {DelimiterCase} from 'type-fest';
+ *
+ * // Simple
+ *
+ * const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
+ *
+ * // Advanced
+ *
+ * type OddlyCasedProperties<T> = {
+ * 	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
+ * };
+ *
+ * interface SomeOptions {
+ * 	dryRun: boolean;
+ * 	includeFile: string;
+ * 	foo: number;
+ * }
+ *
+ * const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
+ * 	'dry#run': true,
+ * 	'include#file': 'bar.js',
+ * 	foo: 123
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ */
+type DelimiterCase<Value, Delimiter extends string> = string extends Value ? Value : Value extends string ? StringArrayToDelimiterCase<SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>, true, WordSeparators, UpperCaseCharacters, Delimiter> : Value;
+//#endregion
+//#region src/application/models/utilityTypes/delimiterCasedPropertiesDeep.d.ts
+/**
+ * Convert object properties to delimiter case recursively.
+ *
+ * This can be useful when, for example, converting some API types from a different style.
+ *
+ * @see DelimiterCase
+ * @see DelimiterCasedProperties
+ *
+ * @example
+ * ```
+ * import type {DelimiterCasedPropertiesDeep} from 'type-fest';
+ *
+ * interface User {
+ * 	userId: number;
+ * 	userName: string;
+ * }
+ *
+ * interface UserWithFriends {
+ * 	userInfo: User;
+ * 	userFriends: User[];
+ * }
+ *
+ * const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
+ * 	'user-info': {
+ * 	'user-id': 1,
+ * 		'user-name': 'Tom',
+ * 	},
+ * 	'user-friends': [
+ * 		{
+ * 			'user-id': 2,
+ * 			'user-name': 'Jerry',
+ * 		},
+ * 		{
+ * 			'user-id': 3,
+ * 			'user-name': 'Spike',
+ * 		},
+ * 	],
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ * @category Object
+ */
+type DelimiterCasedPropertiesDeep<Value, Delimiter extends string> = Value extends NonRecursiveType ? Value : Value extends UnknownArray ? DelimiterCasedPropertiesArrayDeep<Value, Delimiter> : Value extends Set<infer U> ? Set<DelimiterCasedPropertiesDeep<U, Delimiter>> : { [K in keyof Value as DelimiterCase<K, Delimiter>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter> };
+type DelimiterCasedPropertiesArrayDeep<Value extends UnknownArray, Delimiter extends string> = Value extends [] ? [] : Value extends [infer U, ...infer V] ? [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends readonly [infer U, ...infer V] ? readonly [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends readonly [...infer U, infer V] ? [...DelimiterCasedPropertiesDeep<U, Delimiter>, DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends readonly [...infer U, infer V] ? readonly [...DelimiterCasedPropertiesDeep<U, Delimiter>, DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends Array<infer U> ? Array<DelimiterCasedPropertiesDeep<U, Delimiter>> : Value extends ReadonlyArray<infer U> ? ReadonlyArray<DelimiterCasedPropertiesDeep<U, Delimiter>> : never;
+//#endregion
+//#region src/application/models/utilityTypes/snakeCasedPropertiesDeep.d.ts
+/**
+ * Convert object properties to snake case recursively.
+ *
+ * This can be useful when, for example, converting some API types from a different style.
+ *
+ * @see SnakeCase
+ * @see SnakeCasedProperties
+ *
+ * @example
+ * ```
+ * import type {SnakeCasedPropertiesDeep} from 'type-fest';
+ *
+ * interface User {
+ * 	userId: number;
+ * 	userName: string;
+ * }
+ *
+ * interface UserWithFriends {
+ * 	userInfo: User;
+ * 	userFriends: User[];
+ * }
+ *
+ * const result: SnakeCasedPropertiesDeep<UserWithFriends> = {
+ * 	user_info: {
+ * 		user_id: 1,
+ * 		user_name: 'Tom',
+ * 	},
+ * 	user_friends: [
+ * 		{
+ * 			user_id: 2,
+ * 			user_name: 'Jerry',
+ * 		},
+ * 		{
+ * 			user_id: 3,
+ * 			user_name: 'Spike',
+ * 		},
+ * 	],
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ * @category Object
+ */
+type SnakeCasedPropertiesDeep<Value> = DelimiterCasedPropertiesDeep<Value, '_'>;
+//#endregion
+//#region src/application/models/utils/snakeToCamelTransformer.d.ts
+/**
+ * Generic utility to transform snake_case object keys to camelCase at runtime.
+ * This is the runtime equivalent of the CamelCasedPropertiesDeep type utility.
+ */
+/**
+ * Recursively transforms all object keys from snake_case to camelCase
+ */
+declare const transformSnakeToCamel: (obj: unknown) => unknown;
+/**
+ * Recursively transforms all object keys from camelCase to snake_case
+ */
+declare const transformCamelToSnake: (obj: unknown) => unknown;
+//#endregion
+//#region src/application/models/utils/stringToFulfillmentDisplayStatusEnumValue.d.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
+ */
+declare const stringToFulfillmentDisplayStatusEnumValue: (status: string) => FulfillmentDisplayStatus | undefined;
+//#endregion
+//#region src/application/models/validators/validateGraphQLColorsConfig.d.ts
+declare const validateGraphQLColorsConfig: (data: unknown) => ColorMapping | undefined;
+//#endregion
+//#region src/application/models/validators/validateGraphQLFrontendConfig.d.ts
+declare const validateAndTransformPageVariants: (config: Record<string, unknown>) => PageVariantConfig;
+declare const validateAndTransformMountingConfig: (config: Record<string, unknown>, configKey: string) => WidgetMountingConfig;
+declare const validateAndTransformWidgetConfig: (config: Record<string, unknown>, configKey: string) => WidgetConfig;
+declare const validateGraphQLFrontendConfig: (data: unknown) => FrontendConfig | undefined;
+//#endregion
+//#region src/application/models/validators/validateGraphQLOrgId.d.ts
+declare const validateGraphQLOrgId: (data: unknown) => string | undefined;
+//#endregion
+//#region src/application/models/validators/validateMobilePLPChatPlacementParameter.d.ts
+declare const validateMobilePLPChatPlacementParameter: (value: unknown) => MobilePLPChatPlacementParameter | undefined;
+//#endregion
+//#region src/application/models/validators/validateOrganizationConfig.d.ts
+declare const validateOrganizationConfig: (data: unknown) => OrganizationConfig$1 | undefined;
+//#endregion
+//#region src/application/models/validators/validateOrgConfigResults.d.ts
+/**
+ *
+ * @param data
+ * @returns
+ */
+declare const validateOrgConfigResults: (data: unknown) => OrgConfig | undefined;
+//#endregion
+//#region src/application/models/validators/validateResponse.d.ts
+declare const validateResponse: (data: unknown) => Response$1 | undefined;
+//#endregion
+//#region src/application/models/validators/validateSuggestion.d.ts
+declare const validateSuggestion: (data: unknown) => Suggestion$1 | undefined;
+//#endregion
+//#region src/application/models/validators/validateUserEvent.d.ts
+declare const validateUserEvent: (data: unknown) => UserEvent$1 | undefined;
+//#endregion
+export { ApiOrderItemInfo, ApiOrderResponseAttributes, ApiOrganizationConfig, AppLoadedUserEvent, AppUnloadedEvent, BaseEcommerceEvent, type CachedValue, type ClientDetails, Context$1 as Context, ConversationalSearchIds, DelimiterCase, DelimiterCasedPropertiesDeep, FormField, FormSubmitted, FormSubmittedAttributes$1 as FormSubmittedAttributes, GA4EcommerceEvent, GenerationParams$1 as GenerationParams, GoogleAnalyticsEvents, Message, MessageRole, MessageType, MobilePLPChatPlacementParameter, NextMessageRequest$1 as NextMessageRequest, OrgShortName, PDPAttributes$1 as PDPAttributes, PDPUserEvent, PLPAttributes$1 as PLPAttributes, PLPUserEvent, PageVisitAttributes, PageVisitEvent, ProductExperiment, ProductMessageMetadata, ProductSearchMessageMetadata, QueryTypedAttributes$1 as QueryTypedAttributes, QueryTypedUserEvent, SearchAttributes$1 as SearchAttributes, SearchUserEvent, SnakeCasedPropertiesDeep, SpanxTakeAQuizCtaParameter, SpiffyEventName, SplitIncludingDelimiters, Suggestion$1 as Suggestion, SuggestionClickedAttributes$1 as SuggestionClickedAttributes, SuggestionsClickedUserEvent, SupportedEventRequest$1 as SupportedEventRequest, UAEcommerceEvent, UserEvent$1 as UserEvent, UserEventAttributes, getMerchantOrgIdQuery, hasPropertyOfType, isApiFormResponseAttributes, isApiFormSubmittedResponseAttributes, isApiOrderResponseAttributes, isApiOrgConfigResults, isApiOrganizationConfig, isApiPLPEventAttributes, isApiPLPIdAttribute, isApiPageResponseAttributes, isApiProductSearchFilterResponseAttributes, isBaseEcommerceEvent, isGA4EcommerceEvent, isGraphQLColorsConfig, isLegacyUAEcommerceEvent, isMobilePLPChatPlacementParameter, isSpanxTakeAQuizCtaParameter, isVariantInfo, stringToFulfillmentDisplayStatusEnumValue, transformCamelToSnake, transformSnakeToCamel, validateAndTransformMountingConfig, validateAndTransformPageVariants, validateAndTransformWidgetConfig, validateGraphQLColorsConfig, validateGraphQLFrontendConfig, validateGraphQLOrgId, validateMobilePLPChatPlacementParameter, validateOrgConfigResults, validateOrganizationConfig, validateResponse, validateSuggestion, validateUserEvent };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-Bs0QtkSu.d.ts","names":[],"sources":["../src/application/models/cachedValue.d.ts","../src/application/models/clientDetails.d.ts","../src/application/models/conversationalSearchIds.d.ts","../src/application/models/dataLayer.d.ts","../src/application/models/events.d.ts","../src/application/models/googleAnalyticsEvents.d.ts","../src/application/models/message.d.ts","../src/application/models/mobilePLPChatPlacementParameter.d.ts","../src/application/models/orgsEnum.d.ts","../src/application/models/productExperiment.d.ts","../src/application/models/spanxTakeAQuizCtaParameter.d.ts","../src/application/models/api/context.d.ts","../src/application/models/api/generationParams.d.ts","../src/application/models/api/userEvent.d.ts","../src/application/models/api/nextMessageRequest.d.ts","../src/application/models/api/suggestion.d.ts","../src/application/models/api/supportedEventRequest.d.ts","../src/application/models/graphql/queries/getMerchantOrgIdQuery.d.ts","../src/application/models/guards/isBaseEcommerceEvent.d.ts","../src/application/models/guards/isGA4EcommerceEvent.d.ts","../src/application/models/guards/isLegacyUAEcommerceEvent.d.ts","../src/application/models/guards/isMobilePLPChatPlacementParameter.d.ts","../src/application/models/guards/isSpanxTakeAQuizCtaParameter.d.ts","../src/application/models/guards/isVariantInfo.d.ts","../src/application/models/guards/utils.d.ts","../src/application/models/guards/api/isApiFormResponse.d.ts","../src/application/models/guards/api/isApiFormSubmittedResponseAttributes.d.ts","../src/application/models/guards/api/isApiOrderResponseAttributes.d.ts","../src/application/models/guards/api/isApiOrganizationConfig.d.ts","../src/application/models/guards/api/isApiOrgConfigResults.d.ts","../src/application/models/guards/api/isApiPageResponseAttributes.d.ts","../src/application/models/guards/api/isApiPLPEventAttributes.d.ts","../src/application/models/guards/api/isApiProductSearchFilterAttributes.d.ts","../src/application/models/guards/graphQL/isGraphQLColorsConfig.d.ts","../src/application/models/utilityTypes/delimiterCase.d.ts","../src/application/models/utilityTypes/delimiterCasedPropertiesDeep.d.ts","../src/application/models/utilityTypes/snakeCasedPropertiesDeep.d.ts","../src/application/models/utils/snakeToCamelTransformer.d.ts","../src/application/models/utils/stringToFulfillmentDisplayStatusEnumValue.d.ts","../src/application/models/validators/validateGraphQLColorsConfig.d.ts","../src/application/models/validators/validateGraphQLFrontendConfig.d.ts","../src/application/models/validators/validateGraphQLOrgId.d.ts","../src/application/models/validators/validateMobilePLPChatPlacementParameter.d.ts","../src/application/models/validators/validateOrganizationConfig.d.ts","../src/application/models/validators/validateOrgConfigResults.d.ts","../src/application/models/validators/validateResponse.d.ts","../src/application/models/validators/validateSuggestion.d.ts","../src/application/models/validators/validateUserEvent.d.ts"],"sourcesContent":["interface CachedValue {\n    value: unknown;\n    expiry: number;\n}\nexport type { CachedValue };\n","interface ClientDetails {\n    os?: string;\n    osVersion?: string;\n    deviceBrand?: string;\n    deviceManufacturer?: string;\n    deviceModel?: string;\n    carrier?: string;\n    country?: string;\n    region?: string;\n    browser?: string;\n    browserVersion?: string;\n    browserIpAddress?: string;\n    userAgent?: string;\n}\nexport type { ClientDetails, };\n","export type ConversationalSearchIds = {\n    conversationalSearchEntrypointId?: string;\n    conversationalSearchInputId?: string;\n    conversationalSearchModalId?: string;\n};\n","/**\n * Base interface for common properties across all ecommerce events\n */\nexport interface BaseEcommerceEvent {\n    event: string;\n    ecommerce: UAEcommerceData | GA4EcommerceData;\n}\n/**\n * Legacy universal analytics data. The actual payload contains more fields, but we\n * only need the ones listed below.\n */\ninterface UAEcommerceData {\n    add: {\n        products: {\n            name: string;\n            category: string;\n            price: string;\n            quantity: string;\n        }[];\n        currencyCode: string;\n    };\n}\n/**\n * Google Analytics 4 data. The actual payload contains more fields, but we\n * only need the ones listed below.\n */\ninterface GA4EcommerceData {\n    currency: string;\n    items: {\n        item_name: string;\n        item_category: string;\n        price: number;\n        quantity: number;\n    }[];\n}\nexport interface UAEcommerceEvent extends BaseEcommerceEvent {\n    ecommerce: UAEcommerceData;\n}\nexport interface GA4EcommerceEvent extends BaseEcommerceEvent {\n    ecommerce: GA4EcommerceData;\n}\nexport {};\n","export declare enum SpiffyEventName {\n    WidgetOpen = \"spiffy:widgetopen\",\n    WidgetClose = \"spiffy:widgetclose\"\n}\n","declare enum GoogleAnalyticsEvents {\n    ADD_TO_CART_v1 = \"add_to_cart\",\n    ADD_TO_CART_v2 = \"addToCart\"\n}\nexport { GoogleAnalyticsEvents };\n","import { CustServiceAttachment, FormType } from '@spiffy-ai/commerce-api-client';\nimport { OrderResponseAttributes, ProductResponseAttributes, ReviewResponseAttributes, PageResponseAttributes, TextResponseAttributes, SearchResponseAttributes, SearchProductResponseAttributes, AcceptableFormFieldType, SearchProductFilterAttributes } from './api/response';\nexport declare enum MessageRole {\n    User = \"user\",\n    Assistant = \"assistant\"\n}\nexport declare 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}\nexport type Message = {\n    id: string;\n    role: MessageRole;\n    createdAt: string;\n} & (TextMessageMetadata | QueryTypedMetadata | SuggestionMessageMetadata | ProductMessageMetadata | ProductSearchMessageMetadata | ReviewMessageMetadata | SeparatorMessageMetadata | PageMessageMetadata | SearchMessageMetadata | AttachmentMetadata | CXAgentResponseMetadata | FormMessageMetadata | OrderMessageMetadata | ProductSearchFilterMetadata);\ntype AttachmentMetadata = {\n    type: MessageType.Attachment;\n    metadata: {\n        message?: string;\n        attachment: CustServiceAttachment[];\n    };\n};\ntype CXAgentResponseMetadata = {\n    type: MessageType.CXAgentResponse;\n    metadata: {\n        message: string;\n        agentName: string;\n    };\n};\ntype TextMessageMetadata = {\n    type: MessageType.Text;\n    metadata: TextResponseAttributes['attributes'];\n};\ntype QueryTypedMetadata = {\n    type: MessageType.QueryTyped;\n    metadata: TextResponseAttributes['attributes'];\n};\ntype SuggestionMessageMetadata = {\n    type: MessageType.SuggestionClicked;\n    metadata: {\n        suggestionId: string;\n        suggestionContent: string;\n    };\n};\nexport type ProductMessageMetadata = {\n    type: MessageType.Product;\n    metadata: ProductResponseAttributes['attributes'];\n};\nexport type ProductSearchMessageMetadata = {\n    type: MessageType.ProductSearch;\n    metadata: SearchProductResponseAttributes['attributes'];\n};\ntype ReviewMessageMetadata = {\n    type: MessageType.Review;\n    metadata: ReviewResponseAttributes['attributes'];\n};\ntype SeparatorMessageMetadata = {\n    type: MessageType.Separator;\n};\ntype PageMessageMetadata = {\n    type: MessageType.Page;\n    metadata: PageResponseAttributes['attributes'];\n};\ntype SearchMessageMetadata = {\n    type: MessageType.Search;\n    metadata: SearchResponseAttributes['attributes'];\n};\ntype ProductSearchFilterMetadata = {\n    type: MessageType.ProductSearchFilter;\n    metadata: SearchProductFilterAttributes['attributes'];\n};\nexport type FormField = {\n    key: string;\n    title: string;\n    type: AcceptableFormFieldType;\n    required: boolean;\n    format?: 'email';\n    value?: string;\n};\ntype FormMessageMetadata = {\n    type: MessageType.Form;\n    metadata: {\n        formType?: FormType;\n        fields: FormField[];\n    };\n};\ntype OrderMessageMetadata = {\n    type: MessageType.Order;\n    metadata: OrderResponseAttributes['attributes'];\n};\nexport {};\n","export interface MobilePLPChatPlacementParameter {\n    rowIndex: number;\n}\n","export declare const OrgShortName: {\n    readonly Coterie: \"coterie\";\n    readonly ForLoveAndLemons: \"for-love-and-lemons\";\n    readonly Greenpan: \"greenpan\";\n    readonly JordanCraig: \"jordan-craig\";\n    readonly LarryAndSerges: \"larry_and_serges\";\n    readonly LeapsAndRebounds: \"leaps-and-rebounds\";\n    readonly MantraBrand: \"mantra-brand\";\n    readonly Spanx: \"spanx\";\n    readonly SpanxStaging: \"staging-spanx\";\n    readonly Supergoop: \"supergoop\";\n    readonly UniqueVintage: \"unique-vintage\";\n    readonly JackArcher: \"jack-archer\";\n    readonly SkinPerfection: \"skin-perfection\";\n    readonly LookOptic: \"look-optic\";\n    readonly FiveCbd: \"five-cbd\";\n    readonly SnapSupplements: \"snap-supplements\";\n    readonly Longevityrx: \"longevityrx\";\n    readonly VenaCbd: \"vena-cbd\";\n    readonly Medterra: \"medterra\";\n    readonly Modells: \"modells\";\n    readonly PressedFloral: \"pressed-floral\";\n    readonly KindredBravely: \"kindred-bravely\";\n    readonly WineEnthusiast: \"wine-enthusiast\";\n    readonly HomegrownCannabis: \"homegrown-cannabis\";\n    readonly DreamlandBaby: \"dreamland-baby\";\n    readonly Bandolier: \"bandolier\";\n    readonly WestonJonBoucher: \"weston-jon-boucher\";\n    readonly KutFromTheKloth: \"kut-from-the-kloth\";\n    readonly GrooveLife: \"groove-life\";\n    readonly Carpe: \"carpe\";\n    readonly WolfTactical: \"wolf-tactical\";\n    readonly WolfMattress: \"wolfmattress\";\n    readonly Default: \"default\";\n};\n","export declare enum ProductExperiment {\n    Default = \"default\"\n}\n","export interface SpanxTakeAQuizCtaParameter {\n    text?: string;\n    value?: string;\n}\n","import { Context as ApiContext } from '@spiffy-ai/commerce-api-client';\nimport { CamelCasedPropertiesDeep } from 'src/application/models/utilityTypes';\nexport interface Context extends CamelCasedPropertiesDeep<ApiContext> {\n}\n","import { GenerationParams as ApiGenerationParams } from '@spiffy-ai/commerce-api-client';\nimport { CamelCasedPropertiesDeep } from 'src/application/models/utilityTypes';\nexport interface GenerationParams extends CamelCasedPropertiesDeep<ApiGenerationParams> {\n}\n","import { PDPAttributes as ApiPDPAttributes, PLPAttributes as ApiPLPAttributes, QueryTypedAttributes as ApiQueryTypedAttributes, SearchAttributes as ApiSearchAttributes, SuggestionClickedAttributes as ApiSuggestionClickedAttributes, UserEvent as ApiUserEvent, FormType, PageVisitCategory, UserEventCategory } from '@spiffy-ai/commerce-api-client';\nimport { CamelCasedPropertiesDeep } from 'src/application/models/utilityTypes';\nexport interface PDPAttributes extends CamelCasedPropertiesDeep<ApiPDPAttributes> {\n}\nexport interface PLPAttributes extends CamelCasedPropertiesDeep<ApiPLPAttributes> {\n}\nexport interface SearchAttributes extends CamelCasedPropertiesDeep<ApiSearchAttributes> {\n}\nexport interface QueryTypedAttributes extends CamelCasedPropertiesDeep<ApiQueryTypedAttributes> {\n}\nexport interface FormSubmittedAttributes {\n    filledSchema: Record<string, unknown>;\n    formResponseId: string;\n    formType: FormType;\n}\nexport interface PageVisitAttributes {\n    url: string;\n    pageVisitCategory: PageVisitCategory;\n}\nexport interface SuggestionClickedAttributes extends CamelCasedPropertiesDeep<ApiSuggestionClickedAttributes> {\n}\nexport type UserEventAttributes = PDPAttributes | PLPAttributes | QueryTypedAttributes | SearchAttributes | SuggestionClickedAttributes | PageVisitAttributes;\nexport interface PDPUserEvent {\n    category: UserEventCategory.PdpVisit | UserEventCategory.AddToCart;\n    attributes: PDPAttributes;\n}\nexport interface PLPUserEvent {\n    category: UserEventCategory.PlpVisit;\n    attributes: PLPAttributes;\n}\nexport interface QueryTypedUserEvent {\n    category: UserEventCategory.QueryTyped;\n    attributes: QueryTypedAttributes;\n}\nexport interface SearchUserEvent {\n    category: UserEventCategory.Search;\n    attributes: SearchAttributes;\n}\nexport interface SuggestionsClickedUserEvent {\n    category: UserEventCategory.SuggestionClicked;\n    attributes: SuggestionClickedAttributes;\n}\nexport interface AppLoadedUserEvent {\n    category: UserEventCategory.AppLoaded;\n}\nexport interface AppUnloadedEvent {\n    category: UserEventCategory.AppUnloaded;\n}\nexport interface PageVisitEvent {\n    category: UserEventCategory.PageVisit;\n    attributes: PageVisitAttributes;\n}\nexport interface FormSubmitted {\n    category: UserEventCategory.FormSubmitted;\n    attributes: FormSubmittedAttributes;\n}\nexport type UserEvent = CamelCasedPropertiesDeep<Pick<ApiUserEvent, 'event_id' | 'category' | 'created_at'>> & (SuggestionsClickedUserEvent | AppLoadedUserEvent | PDPUserEvent | QueryTypedUserEvent | SearchUserEvent | AppUnloadedEvent | PLPUserEvent | PageVisitEvent | FormSubmitted);\n","import { Context } from './context';\nimport { UserEvent } from './userEvent';\nimport { GenerationParams } from './generationParams';\nexport interface NextMessageRequest {\n    id: string;\n    context: Context;\n    userEvents?: UserEvent[];\n    featureFlags?: Record<string, boolean>;\n    generationParams?: GenerationParams;\n}\n","import { Suggestion as ApiSuggestion } from '@spiffy-ai/commerce-api-client';\nimport { CamelCasedPropertiesDeep } from 'src/application/models/utilityTypes';\nexport interface Suggestion extends CamelCasedPropertiesDeep<ApiSuggestion> {\n}\n","import { UserEvent } from './userEvent';\nimport { Context } from './context';\nexport interface SupportedEventRequest {\n    id: string;\n    context: Context;\n    userEvent: UserEvent;\n}\n","declare const getMerchantOrgIdQuery = \"\\n  query {\\n    me {\\n      org {\\n        id\\n      }\\n    }\\n  }\\n\";\nexport { getMerchantOrgIdQuery };\n","import type { BaseEcommerceEvent } from 'src/application/models';\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 declare const isBaseEcommerceEvent: (data: unknown) => data is BaseEcommerceEvent;\n","import type { GA4EcommerceEvent } from 'src/application/models';\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 declare const isGA4EcommerceEvent: (data: unknown) => data is GA4EcommerceEvent;\n","import type { UAEcommerceEvent } from 'src/application/models';\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 declare const isLegacyUAEcommerceEvent: (data: unknown) => data is UAEcommerceEvent;\n","interface MobilePlpChatPlacementParameter {\n    row_index: number;\n}\nexport declare const isMobilePLPChatPlacementParameter: (value: unknown) => value is MobilePlpChatPlacementParameter;\nexport {};\n","import { SpanxTakeAQuizCtaParameter } from '../spanxTakeAQuizCtaParameter';\nexport declare const isSpanxTakeAQuizCtaParameter: (value: unknown) => value is SpanxTakeAQuizCtaParameter;\n","import { VariantInfo } from '../variantInfo';\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 declare const isVariantInfo: (variantInfo: unknown) => variantInfo is VariantInfo;\n","/**\n * Checks if an object has a property of a specific type\n *\n * @param obj - The object to check\n * @param prop - The property name to check\n * @param type - The expected type of the property\n * @param isOptional - Whether the property is optional (defaults to false)\n *\n * @returns boolean indicating if the object has the property of the specified type\n */\nexport declare const hasPropertyOfType: <T extends object>(obj: unknown, prop: keyof T, type: \"string\" | \"number\" | \"boolean\" | \"object\" | \"array\", isOptional?: boolean) => obj is T;\n","import { ApiFormResponseAttributes } from 'src/application/models/api/responseGenerics';\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 declare const isApiFormResponseAttributes: (data: unknown) => data is ApiFormResponseAttributes;\n","import { FormSubmittedAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiFormSubmittedResponseAttributes: (data: unknown) => data is FormSubmittedAttributes;\n","import { OrderItemInfo, OrderResponseAttributes } from '@spiffy-ai/commerce-api-client';\nexport interface ApiOrderItemInfo 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}\nexport interface ApiOrderResponseAttributes extends Omit<OrderResponseAttributes, 'created_at' | 'latest_event_date' | 'line_items'> {\n    created_at: string;\n    latest_event_date: string;\n    line_items: ApiOrderItemInfo[];\n}\nexport declare const isApiOrderResponseAttributes: (data: unknown) => data is ApiOrderResponseAttributes;\n","import { OrganizationConfig } from '@spiffy-ai/commerce-api-client';\ninterface ApiOrgAnalyticsConfigAmplitude {\n    session_replay_enabled: boolean;\n    session_replay_sample_rate: number;\n    tracking_enabled: boolean;\n}\ninterface ApiOrgAnalyticsConfigCustomerService {\n    provider: string;\n}\ninterface ApiOrgAnalyticsConfigGoogleAnalytics {\n    measurement_id: string;\n}\ninterface ApiOrgAnalyticsConfig {\n    amplitude?: ApiOrgAnalyticsConfigAmplitude;\n    customer_service?: ApiOrgAnalyticsConfigCustomerService;\n    google_analytics?: ApiOrgAnalyticsConfigGoogleAnalytics;\n}\nexport interface ApiOrganizationConfig extends OrganizationConfig {\n    config: ApiOrgAnalyticsConfig;\n}\n/**\n *\n * @param data\n * @returns\n */\nexport declare const isApiOrganizationConfig: (data: unknown) => data is ApiOrganizationConfig;\nexport {};\n","import { StatsigExperiment as ApiOrgConfigExperiment, StatsigFeatureGate as ApiOrgConfigFeatureGate, OrganizationSettings as ApiOrgConfigOrganizationSettings } from '@spiffy-ai/commerce-api-client';\nimport { ApiOrganizationConfig } from './isApiOrganizationConfig';\ninterface ApiOrgConfigResults {\n    configs: ApiOrganizationConfig[];\n    experiments: ApiOrgConfigExperiment[];\n    gates: ApiOrgConfigFeatureGate[];\n    org: ApiOrgConfigOrganizationSettings;\n}\n/**\n *\n * @param data\n * @returns\n */\nexport declare const isApiOrgConfigResults: (data: unknown) => data is Required<ApiOrgConfigResults>;\nexport {};\n","import { ApiPageResponseAttributes } from 'src/application/models/api/responseGenerics';\nexport declare const isApiPageResponseAttributes: (obj: unknown) => obj is ApiPageResponseAttributes;\n","import { PLPAttributes, PLPIdAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiPLPIdAttribute: (data: unknown) => data is PLPIdAttributes;\nexport declare const isApiPLPEventAttributes: (data: unknown) => data is PLPAttributes;\n","import { ProductSearchFilterResponseAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiProductSearchFilterResponseAttributes: (attributes: unknown) => attributes is ProductSearchFilterResponseAttributes;\n","import { GetMerchantColorsQueryData } from 'src/application/models/graphql';\nexport declare const isGraphQLColorsConfig: (data: unknown) => data is GetMerchantColorsQueryData;\n","import type { UpperCaseCharacters, WordSeparators } from './internal';\ntype UpperCaseToLowerCase<T extends string> = T extends Uppercase<T> ? Lowercase<T> : T;\ntype SplitIncludingDelimiters_<Source extends string, Delimiter extends string> = Source extends '' ? [] : Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}` ? Source extends `${FirstPart}${infer UsedDelimiter}${SecondPart}` ? UsedDelimiter extends Delimiter ? Source extends `${infer FirstPart}${UsedDelimiter}${infer SecondPart}` ? [\n    ...SplitIncludingDelimiters<FirstPart, Delimiter>,\n    UsedDelimiter,\n    ...SplitIncludingDelimiters<SecondPart, Delimiter>\n] : never : never : never : [Source];\n/**\n * Unlike a simpler split, this one includes the delimiter splitted on in the resulting array literal. This is to enable splitting on, for example, upper-case characters.\n *\n * @category Template literal\n */\nexport type SplitIncludingDelimiters<Source extends string, Delimiter extends string> = SplitIncludingDelimiters_<UpperCaseToLowerCase<Source>, Delimiter>;\n/**\n *Format a specific part of the splitted string literal that `StringArrayToDelimiterCase<>` fuses together, ensuring desired casing.\n *\n *@see StringArrayToDelimiterCase\n */\ntype StringPartToDelimiterCase<StringPart extends string, Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> = StringPart extends UsedWordSeparators ? Delimiter : Start extends true ? Lowercase<StringPart> : StringPart extends UsedUpperCaseCharacters ? `${Delimiter}${Lowercase<StringPart>}` : StringPart;\n/**\n * Takes the result of a splitted string literal and recursively concatenates it together into the desired casing.\n *\n * It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensure it's fully encapsulated.\n *\n * @see SplitIncludingDelimiters\n */\ntype StringArrayToDelimiterCase<Parts extends readonly any[], Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> = Parts extends [`${infer FirstPart}`, ...infer RemainingParts] ? `${StringPartToDelimiterCase<FirstPart, Start, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}${StringArrayToDelimiterCase<RemainingParts, false, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}` : Parts extends [string] ? string : '';\n/**\n * Convert a string literal to a custom string delimiter casing.\n *\n * This can be useful when, for example, converting a camel-cased object property to an oddly cased one.\n *\n * @see KebabCase\n * @see SnakeCase\n *\n * @example\n * ```\n * import type {DelimiterCase} from 'type-fest';\n *\n * // Simple\n *\n * const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';\n *\n * // Advanced\n *\n * type OddlyCasedProperties<T> = {\n * \t[K in keyof T as DelimiterCase<K, '#'>]: T[K]\n * };\n *\n * interface SomeOptions {\n * \tdryRun: boolean;\n * \tincludeFile: string;\n * \tfoo: number;\n * }\n *\n * const rawCliOptions: OddlyCasedProperties<SomeOptions> = {\n * \t'dry#run': true,\n * \t'include#file': 'bar.js',\n * \tfoo: 123\n * };\n * ```\n *\n * @category Change case\n * @category Template literal\n */\nexport type DelimiterCase<Value, Delimiter extends string> = string extends Value ? Value : Value extends string ? StringArrayToDelimiterCase<SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>, true, WordSeparators, UpperCaseCharacters, Delimiter> : Value;\nexport {};\n","import type { DelimiterCase } from './delimiterCase';\nimport type { NonRecursiveType } from './internal';\nimport type { UnknownArray } from './unknownArray';\n/**\n * Convert object properties to delimiter case recursively.\n *\n * This can be useful when, for example, converting some API types from a different style.\n *\n * @see DelimiterCase\n * @see DelimiterCasedProperties\n *\n * @example\n * ```\n * import type {DelimiterCasedPropertiesDeep} from 'type-fest';\n *\n * interface User {\n * \tuserId: number;\n * \tuserName: string;\n * }\n *\n * interface UserWithFriends {\n * \tuserInfo: User;\n * \tuserFriends: User[];\n * }\n *\n * const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {\n * \t'user-info': {\n * \t'user-id': 1,\n * \t\t'user-name': 'Tom',\n * \t},\n * \t'user-friends': [\n * \t\t{\n * \t\t\t'user-id': 2,\n * \t\t\t'user-name': 'Jerry',\n * \t\t},\n * \t\t{\n * \t\t\t'user-id': 3,\n * \t\t\t'user-name': 'Spike',\n * \t\t},\n * \t],\n * };\n * ```\n *\n * @category Change case\n * @category Template literal\n * @category Object\n */\nexport type DelimiterCasedPropertiesDeep<Value, Delimiter extends string> = Value extends NonRecursiveType ? Value : Value extends UnknownArray ? DelimiterCasedPropertiesArrayDeep<Value, Delimiter> : Value extends Set<infer U> ? Set<DelimiterCasedPropertiesDeep<U, Delimiter>> : {\n    [K in keyof Value as DelimiterCase<K, Delimiter>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter>;\n};\ntype DelimiterCasedPropertiesArrayDeep<Value extends UnknownArray, Delimiter extends string> = Value extends [] ? [] : Value extends [infer U, ...infer V] ? [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends readonly [infer U, ...infer V] ? readonly [\n    DelimiterCasedPropertiesDeep<U, Delimiter>,\n    ...DelimiterCasedPropertiesDeep<V, Delimiter>\n] : Value extends readonly [...infer U, infer V] ? [\n    ...DelimiterCasedPropertiesDeep<U, Delimiter>,\n    DelimiterCasedPropertiesDeep<V, Delimiter>\n] : Value extends readonly [...infer U, infer V] ? readonly [\n    ...DelimiterCasedPropertiesDeep<U, Delimiter>,\n    DelimiterCasedPropertiesDeep<V, Delimiter>\n] : Value extends Array<infer U> ? Array<DelimiterCasedPropertiesDeep<U, Delimiter>> : Value extends ReadonlyArray<infer U> ? ReadonlyArray<DelimiterCasedPropertiesDeep<U, Delimiter>> : never;\nexport {};\n","import type { DelimiterCasedPropertiesDeep } from './delimiterCasedPropertiesDeep';\n/**\n * Convert object properties to snake case recursively.\n *\n * This can be useful when, for example, converting some API types from a different style.\n *\n * @see SnakeCase\n * @see SnakeCasedProperties\n *\n * @example\n * ```\n * import type {SnakeCasedPropertiesDeep} from 'type-fest';\n *\n * interface User {\n * \tuserId: number;\n * \tuserName: string;\n * }\n *\n * interface UserWithFriends {\n * \tuserInfo: User;\n * \tuserFriends: User[];\n * }\n *\n * const result: SnakeCasedPropertiesDeep<UserWithFriends> = {\n * \tuser_info: {\n * \t\tuser_id: 1,\n * \t\tuser_name: 'Tom',\n * \t},\n * \tuser_friends: [\n * \t\t{\n * \t\t\tuser_id: 2,\n * \t\t\tuser_name: 'Jerry',\n * \t\t},\n * \t\t{\n * \t\t\tuser_id: 3,\n * \t\t\tuser_name: 'Spike',\n * \t\t},\n * \t],\n * };\n * ```\n *\n * @category Change case\n * @category Template literal\n * @category Object\n */\nexport type SnakeCasedPropertiesDeep<Value> = DelimiterCasedPropertiesDeep<Value, '_'>;\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 * Recursively transforms all object keys from snake_case to camelCase\n */\nexport declare const transformSnakeToCamel: (obj: unknown) => unknown;\n/**\n * Recursively transforms all object keys from camelCase to snake_case\n */\nexport declare const transformCamelToSnake: (obj: unknown) => unknown;\n","import { FulfillmentDisplayStatus } from '@spiffy-ai/commerce-api-client';\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 declare const stringToFulfillmentDisplayStatusEnumValue: (status: string) => FulfillmentDisplayStatus | undefined;\n","import { ColorMapping } from \"src/application/models/colorsConfig\";\nexport declare const validateGraphQLColorsConfig: (data: unknown) => ColorMapping | undefined;\n","import { FrontendConfig } from 'src/application/models/frontendConfig';\nimport { WidgetConfig, PageVariantConfig, WidgetMountingConfig } from 'src/contexts/types';\nexport declare const validateAndTransformPageVariants: (config: Record<string, unknown>) => PageVariantConfig;\nexport declare const validateAndTransformMountingConfig: (config: Record<string, unknown>, configKey: string) => WidgetMountingConfig;\nexport declare const validateAndTransformWidgetConfig: (config: Record<string, unknown>, configKey: string) => WidgetConfig;\nexport declare const validateGraphQLFrontendConfig: (data: unknown) => FrontendConfig | undefined;\n","export declare const validateGraphQLOrgId: (data: unknown) => string | undefined;\n","import { MobilePLPChatPlacementParameter } from '../mobilePLPChatPlacementParameter';\nexport declare const validateMobilePLPChatPlacementParameter: (value: unknown) => MobilePLPChatPlacementParameter | undefined;\n","import { OrganizationConfig } from 'src/application/models/api/organizationConfig';\nexport declare const validateOrganizationConfig: (data: unknown) => OrganizationConfig | undefined;\n","import { OrgConfig } from 'src/application/models/api/orgConfigResults';\n/**\n *\n * @param data\n * @returns\n */\nexport declare const validateOrgConfigResults: (data: unknown) => OrgConfig | undefined;\n","import { Response } from 'src/application/models/index';\nexport declare const validateResponse: (data: unknown) => Response | undefined;\n","import { Suggestion } from '../api/suggestion';\nexport declare const validateSuggestion: (data: unknown) => Suggestion | undefined;\n","import { UserEvent } from 'src/application/models/index';\nexport declare const validateUserEvent: (data: unknown) => UserEvent | undefined;\n"],"mappings":"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"}