@envive-ai/react-hooks 0.2.1 → 0.2.2

package/dist/index-CiWEYzXl.d.cts

@@ -0,0 +1,184 @@
+import { CamelCasedPropertiesDeep } from "./index-CESxqFso.cjs";
+import { FormResponseAttributesFormCategory, FormType, FulfillmentDisplayStatus, PDPAttributes, ProductSearchResponseAttributes, QueryTypedAttributes, Response, ResponseCategory, ResponseProductAttributes, SearchAttributes, SearchResponseProduct, Suggestion, SuggestionClickedAttributes, UserEvent } from "@spiffy-ai/commerce-api-client";
+
+//#region src/application/models/guards/api/isApiPDPEventAttributes.d.ts
+declare const isApiPDPAttributes: (data: unknown) => data is PDPAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiQueryTypedEventAttributes.d.ts
+declare const isApiQueryTypedAttributes: (data: unknown) => data is QueryTypedAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiResponse.d.ts
+declare const isApiResponse: (data: unknown) => data is Response;
+//#endregion
+//#region src/application/models/guards/api/isApiProductResponseAttributes.d.ts
+declare const isApiProductResponseAttributes: (attributes: unknown) => attributes is ResponseProductAttributes;
+//#endregion
+//#region src/application/models/api/response.d.ts
+interface ReviewRichInformation extends CamelCasedPropertiesDeep<ApiReviewRichInformation> {}
+type AcceptableFormFieldType = 'string' | 'number' | 'boolean' | 'object' | 'array';
+interface OrderItemInfo$1 {
+  itemTitle: string;
+  itemPrice: number;
+  itemQuantity: number;
+  orderItemId: string;
+  image?: string;
+  inTransitAt?: string;
+  deliveredAt?: string;
+  estimatedDeliveryAt?: string;
+  fulfillmentDisplayStatus?: FulfillmentDisplayStatus;
+  trackingUrl?: string;
+}
+interface OrderResponseAttributes$1 {
+  category: ResponseCategory.Order;
+  attributes: {
+    orderId: string;
+    orderNumber: string;
+    createdAt: string;
+    latestEventDate: string;
+    lineItems: OrderItemInfo$1[];
+  };
+}
+interface TextResponseAttributes {
+  category: ResponseCategory.Text;
+  attributes: CamelCasedPropertiesDeep<ApiTextResponseAttributes>;
+}
+interface ProductResponseAttributes {
+  category: ResponseCategory.Product;
+  attributes: CamelCasedPropertiesDeep<ResponseProductAttributes & {
+    filters?: {
+      [key: string]: string[];
+    };
+  }>;
+}
+interface SearchResponseProductAttributes {
+  category: ResponseCategory.Product;
+  attributes: CamelCasedPropertiesDeep<SearchResponseProduct>;
+}
+interface SearchResponseAttributes {
+  category: ResponseCategory.Text;
+  attributes: CamelCasedPropertiesDeep<ApiSearchResponseAttributes>;
+}
+interface SearchProductResponseAttributes {
+  category: ResponseCategory.ProductSearch;
+  attributes: CamelCasedPropertiesDeep<ProductSearchResponseAttributes>;
+}
+interface SearchProductFilterAttributes {
+  category: ResponseCategory.ProductSearchFilter;
+  attributes: CamelCasedPropertiesDeep<ApiProductSearchFilterResponseAttributes>;
+}
+interface ReviewResponseAttributes {
+  category: ResponseCategory.Review;
+  attributes: CamelCasedPropertiesDeep<ApiReviewResponseAttributes>;
+}
+interface SeparatorResponseAttributes {
+  category: ResponseCategory.Separator;
+}
+interface PageResponseAttributes {
+  category: ResponseCategory.Page;
+  attributes: CamelCasedPropertiesDeep<ApiPageResponseAttributes>;
+}
+interface FormResponseAttributes {
+  category: ResponseCategory.Form;
+  attributes: {
+    formCategory?: {
+      formType: FormType;
+    };
+    schema: {
+      properties: {
+        [key: string]: {
+          type: AcceptableFormFieldType;
+          title: string;
+          format?: 'email';
+        };
+      };
+      required: string[];
+    };
+  };
+}
+type Response$1 = {
+  id: string;
+  createdAt: string;
+  category: ResponseCategory;
+} & (TextResponseAttributes | ProductResponseAttributes | ReviewResponseAttributes | SeparatorResponseAttributes | PageResponseAttributes | SearchProductResponseAttributes | SearchProductFilterAttributes | FormResponseAttributes | OrderResponseAttributes$1);
+//#endregion
+//#region src/application/models/api/responseGenerics.d.ts
+interface ApiReviewRichInformation {
+  cons?: string[];
+  pros?: string[];
+  review_date?: string;
+  reviewer_title?: string;
+  product_familiarity?: 'IVE_TESTED_IT' | 'I_OWN_IT';
+}
+interface ApiTextResponseAttributes {
+  content: string;
+}
+interface ApiSearchResponseAttributes {
+  search_term: string;
+  selected_filters?: string[];
+  filters?: {
+    [key: string]: string[];
+  };
+}
+interface ApiSearchResponseProductAttributes {
+  response_id?: string;
+}
+interface ApiProductSearchFilterResponseAttributes {
+  filter_name: string;
+}
+interface ApiReviewResponseAttributes {
+  id?: string;
+  product_id?: string;
+  title?: string;
+  reviewer?: string;
+  review?: string;
+  stars?: number;
+  rich_information?: ApiReviewRichInformation;
+  onClick?: () => void;
+}
+interface ApiPageResponseAttributes {
+  id?: string;
+  title?: string;
+  description?: string;
+  url?: string;
+}
+interface ApiFormResponseSchemaAttributes {
+  properties: {
+    [key: string]: {
+      format?: 'email';
+      type: AcceptableFormFieldType;
+      title: string;
+    };
+  };
+  required: Array<keyof ApiFormResponseSchemaAttributes['properties']>;
+}
+interface ApiFormResponseAttributes {
+  form_category?: FormResponseAttributesFormCategory;
+  schema: ApiFormResponseSchemaAttributes;
+}
+//#endregion
+//#region src/application/models/guards/api/isApiReviewResponseAttributes.d.ts
+declare const isApiReviewResponseAttributes: (obj: unknown) => obj is ApiReviewResponseAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiReviewRichInformation.d.ts
+declare const isApiReviewRichInformation: (richInfo: unknown) => richInfo is ApiReviewRichInformation;
+//#endregion
+//#region src/application/models/guards/api/isApiSearchEventAttributes.d.ts
+declare const isApiSearchAttributes: (data: unknown) => data is SearchAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiSuggestion.d.ts
+declare const isSuggestion: (data: unknown) => data is Suggestion;
+//#endregion
+//#region src/application/models/guards/api/isApiSuggestionClickedEventAttributes.d.ts
+declare const isApiSuggestionClickedAttributes: (data: unknown) => data is SuggestionClickedAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiTextResponseAttributes.d.ts
+declare const isApiTextResponseAttributes: (attributes: unknown) => attributes is ApiTextResponseAttributes;
+//#endregion
+//#region src/application/models/guards/api/isApiUserEvent.d.ts
+declare const isApiUserEvent: (data: unknown) => data is UserEvent;
+//#endregion
+//#region src/application/models/guards/api/isApiProductSearchAttributes.d.ts
+declare const isApiProductSearchResponseAttributes: (attributes: unknown) => attributes is ProductSearchResponseAttributes;
+//#endregion
+export { AcceptableFormFieldType, ApiFormResponseAttributes, ApiFormResponseSchemaAttributes, ApiPageResponseAttributes, ApiProductSearchFilterResponseAttributes, ApiReviewResponseAttributes, ApiReviewRichInformation, ApiSearchResponseAttributes, ApiSearchResponseProductAttributes, ApiTextResponseAttributes, FormResponseAttributes, OrderItemInfo$1 as OrderItemInfo, OrderResponseAttributes$1 as OrderResponseAttributes, PageResponseAttributes, ProductResponseAttributes, Response$1 as Response, ReviewResponseAttributes, ReviewRichInformation, SearchProductFilterAttributes, SearchProductResponseAttributes, SearchResponseAttributes, SearchResponseProductAttributes, SeparatorResponseAttributes, TextResponseAttributes, isApiPDPAttributes, isApiProductResponseAttributes, isApiProductSearchResponseAttributes, isApiQueryTypedAttributes, isApiResponse, isApiReviewResponseAttributes, isApiReviewRichInformation, isApiSearchAttributes, isApiSuggestionClickedAttributes, isApiTextResponseAttributes, isApiUserEvent, isSuggestion };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-CiWEYzXl.d.cts","names":[],"sources":["../src/application/models/guards/api/isApiPDPEventAttributes.d.ts","../src/application/models/guards/api/isApiQueryTypedEventAttributes.d.ts","../src/application/models/guards/api/isApiResponse.d.ts","../src/application/models/guards/api/isApiProductResponseAttributes.d.ts","../src/application/models/api/response.d.ts","../src/application/models/api/responseGenerics.d.ts","../src/application/models/guards/api/isApiReviewResponseAttributes.d.ts","../src/application/models/guards/api/isApiReviewRichInformation.d.ts","../src/application/models/guards/api/isApiSearchEventAttributes.d.ts","../src/application/models/guards/api/isApiSuggestion.d.ts","../src/application/models/guards/api/isApiSuggestionClickedEventAttributes.d.ts","../src/application/models/guards/api/isApiTextResponseAttributes.d.ts","../src/application/models/guards/api/isApiUserEvent.d.ts","../src/application/models/guards/api/isApiProductSearchAttributes.d.ts"],"sourcesContent":["import { PDPAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiPDPAttributes: (data: unknown) => data is PDPAttributes;\n","import { QueryTypedAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiQueryTypedAttributes: (data: unknown) => data is QueryTypedAttributes;\n","import { Response } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiResponse: (data: unknown) => data is Response;\n","import { ResponseProductAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiProductResponseAttributes: (attributes: unknown) => attributes is ResponseProductAttributes;\n","import { ResponseCategory } from '@spiffy-ai/commerce-api-client';\nimport { CamelCasedPropertiesDeep } from 'src/application/models/utilityTypes';\nimport type { ProductSearchResponseAttributes as ApiProductSearchResponseAttributes, ResponseProductAttributes as ApiProductResponseAttributes, SearchResponseProduct as ApiSearchResponseProduct, FormType, FulfillmentDisplayStatus } from '@spiffy-ai/commerce-api-client';\nimport { ApiReviewResponseAttributes, ApiReviewRichInformation, ApiPageResponseAttributes, ApiTextResponseAttributes, ApiSearchResponseAttributes, ApiProductSearchFilterResponseAttributes } from 'src/application/models/api/responseGenerics';\nexport interface ReviewRichInformation extends CamelCasedPropertiesDeep<ApiReviewRichInformation> {\n}\nexport type AcceptableFormFieldType = 'string' | 'number' | 'boolean' | 'object' | 'array';\nexport interface OrderItemInfo {\n    itemTitle: string;\n    itemPrice: number;\n    itemQuantity: number;\n    orderItemId: string;\n    image?: string;\n    inTransitAt?: string;\n    deliveredAt?: string;\n    estimatedDeliveryAt?: string;\n    fulfillmentDisplayStatus?: FulfillmentDisplayStatus;\n    trackingUrl?: string;\n}\nexport interface OrderResponseAttributes {\n    category: ResponseCategory.Order;\n    attributes: {\n        orderId: string;\n        orderNumber: string;\n        createdAt: string;\n        latestEventDate: string;\n        lineItems: OrderItemInfo[];\n    };\n}\nexport interface TextResponseAttributes {\n    category: ResponseCategory.Text;\n    attributes: CamelCasedPropertiesDeep<ApiTextResponseAttributes>;\n}\nexport interface ProductResponseAttributes {\n    category: ResponseCategory.Product;\n    attributes: CamelCasedPropertiesDeep<ApiProductResponseAttributes & {\n        filters?: {\n            [key: string]: string[];\n        };\n    }>;\n}\nexport interface SearchResponseProductAttributes {\n    category: ResponseCategory.Product;\n    attributes: CamelCasedPropertiesDeep<ApiSearchResponseProduct>;\n}\nexport interface SearchResponseAttributes {\n    category: ResponseCategory.Text;\n    attributes: CamelCasedPropertiesDeep<ApiSearchResponseAttributes>;\n}\nexport interface SearchProductResponseAttributes {\n    category: ResponseCategory.ProductSearch;\n    attributes: CamelCasedPropertiesDeep<ApiProductSearchResponseAttributes>;\n}\nexport interface SearchProductFilterAttributes {\n    category: ResponseCategory.ProductSearchFilter;\n    attributes: CamelCasedPropertiesDeep<ApiProductSearchFilterResponseAttributes>;\n}\nexport interface ReviewResponseAttributes {\n    category: ResponseCategory.Review;\n    attributes: CamelCasedPropertiesDeep<ApiReviewResponseAttributes>;\n}\nexport interface SeparatorResponseAttributes {\n    category: ResponseCategory.Separator;\n}\nexport interface PageResponseAttributes {\n    category: ResponseCategory.Page;\n    attributes: CamelCasedPropertiesDeep<ApiPageResponseAttributes>;\n}\nexport interface FormResponseAttributes {\n    category: ResponseCategory.Form;\n    attributes: {\n        formCategory?: {\n            formType: FormType;\n        };\n        schema: {\n            properties: {\n                [key: string]: {\n                    type: AcceptableFormFieldType;\n                    title: string;\n                    format?: 'email';\n                };\n            };\n            required: string[];\n        };\n    };\n}\nexport type Response = {\n    id: string;\n    createdAt: string;\n    category: ResponseCategory;\n} & (TextResponseAttributes | ProductResponseAttributes | ReviewResponseAttributes | SeparatorResponseAttributes | PageResponseAttributes | SearchProductResponseAttributes | SearchProductFilterAttributes | FormResponseAttributes | OrderResponseAttributes);\n","import { FormResponseAttributesFormCategory } from '@spiffy-ai/commerce-api-client';\nimport { AcceptableFormFieldType } from './response';\nexport interface ApiReviewRichInformation {\n    cons?: string[];\n    pros?: string[];\n    review_date?: string;\n    reviewer_title?: string;\n    product_familiarity?: 'IVE_TESTED_IT' | 'I_OWN_IT';\n}\nexport interface ApiTextResponseAttributes {\n    content: string;\n}\nexport interface ApiSearchResponseAttributes {\n    search_term: string;\n    selected_filters?: string[];\n    filters?: {\n        [key: string]: string[];\n    };\n}\nexport interface ApiSearchResponseProductAttributes {\n    response_id?: string;\n}\nexport interface ApiProductSearchFilterResponseAttributes {\n    filter_name: string;\n}\nexport interface ApiReviewResponseAttributes {\n    id?: string;\n    product_id?: string;\n    title?: string;\n    reviewer?: string;\n    review?: string;\n    stars?: number;\n    rich_information?: ApiReviewRichInformation;\n    onClick?: () => void;\n}\nexport interface ApiPageResponseAttributes {\n    id?: string;\n    title?: string;\n    description?: string;\n    url?: string;\n}\nexport interface ApiFormResponseSchemaAttributes {\n    properties: {\n        [key: string]: {\n            format?: 'email';\n            type: AcceptableFormFieldType;\n            title: string;\n        };\n    };\n    required: Array<keyof ApiFormResponseSchemaAttributes['properties']>;\n}\nexport interface ApiFormResponseAttributes {\n    form_category?: FormResponseAttributesFormCategory;\n    schema: ApiFormResponseSchemaAttributes;\n}\n","import { ApiReviewResponseAttributes } from 'src/application/models/api/responseGenerics';\nexport declare const isApiReviewResponseAttributes: (obj: unknown) => obj is ApiReviewResponseAttributes;\n","import { ApiReviewRichInformation } from 'src/application/models/api/responseGenerics';\nexport declare const isApiReviewRichInformation: (richInfo: unknown) => richInfo is ApiReviewRichInformation;\n","import { SearchAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiSearchAttributes: (data: unknown) => data is SearchAttributes;\n","import { Suggestion as CommerceSuggestion } from '@spiffy-ai/commerce-api-client';\nexport declare const isSuggestion: (data: unknown) => data is CommerceSuggestion;\n","import { SuggestionClickedAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiSuggestionClickedAttributes: (data: unknown) => data is SuggestionClickedAttributes;\n","import { ApiTextResponseAttributes } from 'src/application/models/api/responseGenerics';\nexport declare const isApiTextResponseAttributes: (attributes: unknown) => attributes is ApiTextResponseAttributes;\n","import { UserEvent } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiUserEvent: (data: unknown) => data is UserEvent;\n","import { ProductSearchResponseAttributes } from '@spiffy-ai/commerce-api-client';\nexport declare const isApiProductSearchResponseAttributes: (attributes: unknown) => attributes is ProductSearchResponseAttributes;\n"],"mappings":";;;;AACA,IAAW,qBAAqB,CAAC,WAAW,cAAc;;;;ACA1D,IAAW,4BAA4B,CAAC,WAAW,qBAAqB;;;;ACAxE,IAAW,gBAAgB,CAAC,WAAW,SAAS;;;;ACAhD,IAAW,iCAAiC,CAAC,WAAW,0BAA0B;;;;ACGlF,IAAW,wBAAwB;CAAC;OAAW;OAAgC;CAAmB;AAClG,IAAA,0BAAA,CAAA,IAAA;AACA,IAAW,kBAAgB,CAAC,WAAW,yBAAyB;AAChE,IAAW,4BAAoB;CAAA;OAAA,iBAAA;OAAA;CAAA;AAC/B,IAAW,yBAAU;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACrB,IAAW,4BAAU;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACrB,IAAW,kCAAa;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACxB,IAAW,2BAAY;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACvB,IAAW,kCAAO;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AAClB,IAAW,gCAAa;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACxB,IAAW,2BAAa;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACxB,IAAW,8BAAqB,CAAA,WAAA,iBAAA,UAAA;AAChC,IAAW,yBAAyB;CAAC;OAAW,iBAAO;OAAA;OAAA;CAAA;AACvD,IAAW,yBAAa;CAAA;OAAA,iBAAA;OAAA;OAAA;CAAA;AACxB,IAAA,aAAA;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;;;;AChBA,IAAW,2BAA2B,CAAC,IAAG;AAC1C,IAAW,4BAAQ,CAAA,IAAA;AACnB,IAAW,8BAAQ,CAAA,IAAA;AACnB,IAAW,qCAAa,CAAA,IAAA;AACxB,IAAW,2CAAgB,CAAA,IAAA;AAC3B,IAAW,8BAA8B,CAAC,WAAW,yBAAC;AACtD,IAAA,4BAAA,CAAA,IAAA;AACA,IAAW,kCAAgC;CAAA;OAAA;OAAA;OAAA;CAAA;AAC3C,IAAW,4BAAQ;CAAA;OAAA;OAAA;CAAA;;;;ACTnB,IAAW,gCAAgC,CAAC,WAAW,4BAA4B;;;;ACAnF,IAAW,6BAA6B,CAAC,WAAW,yBAAyB;;;;ACA7E,IAAW,wBAAwB,CAAC,WAAW,iBAAiB;;;;ACAhE,IAAW,eAAe,CAAC,WAAW,WAAmB;;;;ACAzD,IAAW,mCAAmC,CAAC,WAAW,4BAA4B;;;;ACAtF,IAAW,8BAA8B,CAAC,WAAW,0BAA0B;;;;ACA/E,IAAW,iBAAiB,CAAC,WAAW,UAAU;;;;ACAlD,IAAW,uCAAuC,CAAC,WAAW,gCAAgC"}

package/dist/index-DOii3C6b.d.ts

@@ -0,0 +1,9 @@
+//#region src/config/locators/components/floating-button.d.ts
+declare const FLOATING_BUTTON_ICON_TESTID = "floating-button-icon";
+declare const FLOATING_BUTTON_TEXT_TESTID = "floating-button-text";
+//#endregion
+//#region src/config/locators/components/shadow-dom.d.ts
+declare const SHADOW_DOM_CONTAINER_TESTID = "shadow-dom-container";
+//#endregion
+export { FLOATING_BUTTON_ICON_TESTID, FLOATING_BUTTON_TEXT_TESTID, SHADOW_DOM_CONTAINER_TESTID };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXgtRE9paTNDNmIuZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnL2xvY2F0b3JzL2NvbXBvbmVudHMvZmxvYXRpbmctYnV0dG9uLmQudHMiLCIuLi9zcmMvY29uZmlnL2xvY2F0b3JzL2NvbXBvbmVudHMvc2hhZG93LWRvbS5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWNsYXJlIGNvbnN0IEZMT0FUSU5HX0JVVFRPTl9JQ09OX1RFU1RJRCA9IFwiZmxvYXRpbmctYnV0dG9uLWljb25cIjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IEZMT0FUSU5HX0JVVFRPTl9URVhUX1RFU1RJRCA9IFwiZmxvYXRpbmctYnV0dG9uLXRleHRcIjtcbiIsImV4cG9ydCBkZWNsYXJlIGNvbnN0IFNIQURPV19ET01fQ09OVEFJTkVSX1RFU1RJRCA9IFwic2hhZG93LWRvbS1jb250YWluZXJcIjtcbiJdLCJtYXBwaW5ncyI6IjtBQUFBLElBQVcsOEJBQThCLENBQUMsSUFBSTtBQUM5QyxJQUFXLDhCQUE4QixDQUFDLElBQUk7Ozs7QUNEOUMsSUFBVyw4QkFBOEIsQ0FBQyxJQUFJIn0=

package/dist/index-Dr_c2DDq.d.ts

@@ -0,0 +1,98 @@
+//#region src/application/models/graphql/queries/getMerchantFrontendConfigQuery.d.ts
+declare const getMerchantFrontendConfigQuery: () => string;
+type MountingConfigQueryData = {
+  mounting_config_id?: string;
+  container_id?: string;
+  check_id?: string;
+  parent_insertion_point?: {
+    selector?: string;
+    selection_index?: number;
+    insertion_type?: string;
+  };
+  insertion_point?: {
+    selector?: string;
+    selection_index?: number;
+    insertion_type?: string;
+  };
+  grid_insertion_type?: string;
+  wrapping_element?: {
+    class_name?: string;
+    element?: string;
+    insertion_type?: string;
+  };
+  div_check_selector?: string;
+  suppression_selector?: string;
+  style?: Record<string, string | number>;
+  class_name?: string;
+  data_attributes?: Record<string, string>;
+};
+type WidgetConfigQueryData = {
+  widget_config_id: string;
+  type: string;
+  content_id?: string;
+  [key: string]: unknown;
+};
+type PageVariantCheckQueryData = {
+  check_type: string;
+  [key: string]: unknown;
+};
+type WidgetMountingQueryData = {
+  mounting_config_id: string;
+  widget_config_id?: string;
+  mounting_point_widgets?: Array<{
+    checks: PageVariantCheckQueryData[];
+    widget_config_id: string;
+  }>;
+};
+type PageVariantQueryData = {
+  variant_id: string;
+  variant_type: string;
+  variant_checks: PageVariantCheckQueryData[];
+  widget_mounting: WidgetMountingQueryData[];
+  plp_id_extractor?: string;
+  product_id_extractor?: string;
+  parent_product_id_extractor?: string;
+};
+type UIConfigQueryData = {
+  shortName: string;
+  [key: string]: unknown;
+};
+interface GetMerchantFrontendConfigQueryData {
+  merchant_override_css?: string;
+  page_variants?: PageVariantQueryData[];
+  mounting_configs?: {
+    key: string;
+    config: MountingConfigQueryData;
+  }[];
+  widget_configs?: {
+    key: string;
+    config: WidgetConfigQueryData;
+  }[];
+  ui_configs?: UIConfigQueryData;
+}
+//#endregion
+//#region src/application/models/graphql/queries/getMerchantColorsQuery.d.ts
+declare const getMerchantColorsQuery: () => string;
+interface GetMerchantColorsQueryData {
+  accent_primary: string;
+  accent_secondary: string;
+  background_dark: string;
+  background_light: string;
+  background_primary: string;
+  background_saturated: string;
+  background_secondary: string;
+  background_secondary_dark: string;
+  background_tertiary: string;
+  border_dark: string;
+  border_light: string;
+  border_medium: string;
+  border_outline: string;
+  text_accent: string;
+  text_light: string;
+  text_link: string;
+  text_primary: string;
+  text_secondary: string;
+}
+//#endregion
+export { type GetMerchantColorsQueryData, type GetMerchantFrontendConfigQueryData, type MountingConfigQueryData, type PageVariantCheckQueryData, type PageVariantQueryData, type UIConfigQueryData, type WidgetConfigQueryData, type WidgetMountingQueryData, getMerchantColorsQuery, getMerchantFrontendConfigQuery };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/index-DsiilEj-.d.ts

@@ -0,0 +1,228 @@
+//#region src/application/models/utilityTypes/primitive.d.ts
+/**
+ * Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+ *
+ * @category Type
+ */
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+//#endregion
+//#region src/application/models/utilityTypes/trim.d.ts
+/**
+ * Remove spaces from the left side.
+ */
+type TrimLeft<V extends string> = V extends `${Whitespace}${infer R}` ? TrimLeft<R> : V;
+/**
+ * Remove spaces from the right side.
+ */
+type TrimRight<V extends string> = V extends `${infer R}${Whitespace}` ? TrimRight<R> : V;
+/**
+ * Remove leading and trailing spaces from a string.
+ * @example
+ * ```
+ * import type {Trim} from 'type-fest';
+ *
+ * Trim<' foo '>
+ * //=> 'foo'
+ * ```
+ *
+ * @category String
+ * @category Template literal
+ */
+type Trim<V extends string> = TrimLeft<TrimRight<V>>;
+//#endregion
+//#region src/application/models/utilityTypes/internal.d.ts
+/**
+ * Matches any primitive, `void`, `Date`, or `RegExp` value.
+ */
+type BuiltIns = Primitive | void | Date | RegExp;
+/**
+ * Matches non-recursive types.
+ */
+type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
+/**
+ * Returns a boolean for whether the string is numeric.
+ *
+ * This type is a workaround for [Microsoft/TypeScript#46109](https://github.com/microsoft/TypeScript/issues/46109#issuecomment-930307987).
+ */
+type IsNumeric<T extends string> = T extends `${number}` ? Trim<T> extends T ? true : false : false;
+/**
+ * Returns a boolean for whether the string is lowercased.
+ */
+type IsLowerCase<T extends string> = T extends Lowercase<T> ? true : false;
+/**
+ * Returns a boolean for whether the string is upper-cased.
+ */
+type IsUpperCase<T extends string> = T extends Uppercase<T> ? true : false;
+type WordSeparators = '-' | '_' | Whitespace;
+type Whitespace = '\u{9}' | '\u{A}' | '\u{B}' | '\u{C}' | '\u{D}' | '\u{20}' | '\u{85}' | '\u{A0}' | '\u{1680}' | '\u{2000}' | '\u{2001}' | '\u{2002}' | '\u{2003}' | '\u{2004}' | '\u{2005}' | '\u{2006}' | '\u{2007}' | '\u{2008}' | '\u{2009}' | '\u{200A}' | '\u{2028}' | '\u{2029}' | '\u{202F}' | '\u{205F}' | '\u{3000}' | '\u{FEFF}';
+type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+//#endregion
+//#region src/application/models/utilityTypes/splitWords.d.ts
+type SkipEmptyWord<Word extends string> = Word extends '' ? [] : [Word];
+type RemoveLastCharacter<Sentence extends string, Character extends string> = Sentence extends `${infer LeftSide}${Character}` ? SkipEmptyWord<LeftSide> : never;
+/**
+ * Split a string (almost) like Lodash's `_.words()` function.
+ *
+ * - Split on each word that begins with a capital letter.
+ * - Split on each {@link WordSeparators}.
+ * - Split on numeric sequence.
+ *
+ * @example
+ * ```
+ * type Words0 = SplitWords<'helloWorld'>; // ['hello', 'World']
+ * type Words1 = SplitWords<'helloWORLD'>; // ['hello', 'WORLD']
+ * type Words2 = SplitWords<'hello-world'>; // ['hello', 'world']
+ * type Words3 = SplitWords<'--hello the_world'>; // ['hello', 'the', 'world']
+ * type Words4 = SplitWords<'lifeIs42'>; // ['life', 'Is', '42']
+ * ```
+ *
+ * @internal
+ * @category Change case
+ * @category Template literal
+ */
+type SplitWords<Sentence extends string, LastCharacter extends string = '', CurrentWord extends string = ''> = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}` ? FirstCharacter extends WordSeparators ? [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters>] : LastCharacter extends '' ? SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter> : [false, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>] : [true, false] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>] : [true, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? SplitWords<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`> : [true, true] extends [IsLowerCase<LastCharacter>, IsUpperCase<FirstCharacter>] ? [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>] : [true, true] extends [IsUpperCase<LastCharacter>, IsLowerCase<FirstCharacter>] ? [...RemoveLastCharacter<CurrentWord, LastCharacter>, ...SplitWords<RemainingCharacters, FirstCharacter, `${LastCharacter}${FirstCharacter}`>] : SplitWords<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`> : [...SkipEmptyWord<CurrentWord>];
+//#endregion
+//#region src/application/models/utilityTypes/camelCase.d.ts
+/**
+ * CamelCase options.
+ *
+ * @see {@link CamelCase}
+ */
+type CamelCaseOptions = {
+  /**
+   * Whether to preserved consecutive uppercase letter.
+   *
+   * @default true
+   */
+  preserveConsecutiveUppercase?: boolean;
+};
+/**
+ * Convert an array of words to camel-case.
+ */
+type CamelCaseFromArray<Words extends string[], Options extends CamelCaseOptions, OutputString extends string = ''> = Words extends [infer FirstWord extends string, ...infer RemainingWords extends string[]] ? Options['preserveConsecutiveUppercase'] extends true ? `${Capitalize<FirstWord>}${CamelCaseFromArray<RemainingWords, Options>}` : `${Capitalize<Lowercase<FirstWord>>}${CamelCaseFromArray<RemainingWords, Options>}` : OutputString;
+/**
+ * Convert a string literal to camel-case.
+ *
+ * This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.
+ *
+ * By default, consecutive uppercase letter are preserved. See {@link CamelCaseOptions.preserveConsecutiveUppercase preserveConsecutiveUppercase} option to change this behaviour.
+ *
+ * @example
+ * ```
+ * import type {CamelCase} from 'type-fest';
+ *
+ * // Simple
+ *
+ * const someVariable: CamelCase<'foo-bar'> = 'fooBar';
+ *
+ * // Advanced
+ *
+ * type CamelCasedProperties<T> = {
+ * 	[K in keyof T as CamelCase<K>]: T[K]
+ * };
+ *
+ * interface RawOptions {
+ * 	'dry-run': boolean;
+ * 	'full_family_name': string;
+ * 	foo: number;
+ * 	BAR: string;
+ * 	QUZ_QUX: number;
+ * 	'OTHER-FIELD': boolean;
+ * }
+ *
+ * const dbResult: CamelCasedProperties<RawOptions> = {
+ * 	dryRun: true,
+ * 	fullFamilyName: 'bar.js',
+ * 	foo: 123,
+ * 	bar: 'foo',
+ * 	quzQux: 6,
+ * 	otherField: false
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ */
+type CamelCase<Type, Options extends CamelCaseOptions = {
+  preserveConsecutiveUppercase: true;
+}> = Type extends string ? string extends Type ? Type : Uncapitalize<CamelCaseFromArray<SplitWords<Type extends Uppercase<Type> ? Lowercase<Type> : Type>, Options>> : Type;
+//#endregion
+//#region src/application/models/utilityTypes/unknownArray.d.ts
+/**
+ * Represents an array with `unknown` value.
+ *
+ * Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
+ *
+ * @example
+ * ```
+ * import type {UnknownArray} from 'type-fest';
+ *
+ * type IsArray<T> = T extends UnknownArray ? true : false;
+ *
+ * type A = IsArray<['foo']>;
+ * //=> true
+ *
+ * type B = IsArray<readonly number[]>;
+ * //=> true
+ *
+ * type C = IsArray<string>;
+ * //=> false
+ * ```
+ *
+ * @category Type
+ * @category Array
+ */
+type UnknownArray = readonly unknown[];
+//#endregion
+//#region src/application/models/utilityTypes/camelCasedPropertiesDeep.d.ts
+/**
+ * Convert object properties to camel case recursively.
+ *
+ * This can be useful when, for example, converting some API types from a different style.
+ *
+ * @see CamelCasedProperties
+ * @see CamelCase
+ *
+ * @example
+ * ```
+ * import type {CamelCasedPropertiesDeep} from 'type-fest';
+ *
+ * interface User {
+ * 	UserId: number;
+ * 	UserName: string;
+ * }
+ *
+ * interface UserWithFriends {
+ * 	UserInfo: User;
+ * 	UserFriends: User[];
+ * }
+ *
+ * const result: CamelCasedPropertiesDeep<UserWithFriends> = {
+ * 	userInfo: {
+ * 		userId: 1,
+ * 		userName: 'Tom',
+ * 	},
+ * 	userFriends: [
+ * 		{
+ * 			userId: 2,
+ * 			userName: 'Jerry',
+ * 		},
+ * 		{
+ * 			userId: 3,
+ * 			userName: 'Spike',
+ * 		},
+ * 	],
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ * @category Object
+ */
+type CamelCasedPropertiesDeep<Value, Options extends CamelCaseOptions = {
+  preserveConsecutiveUppercase: true;
+}> = Value extends Function ? Value : Value extends UnknownArray ? CamelCasedPropertiesArrayDeep<Value> : Value extends Set<infer U> ? Set<CamelCasedPropertiesDeep<U, Options>> : { [K in keyof Value as CamelCase<K, Options>]: CamelCasedPropertiesDeep<Value[K], Options> };
+type CamelCasedPropertiesArrayDeep<Value extends UnknownArray> = Value extends [] ? [] : Value extends [infer U, ...infer V] ? [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>] : Value extends readonly [infer U, ...infer V] ? readonly [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>] : Value extends readonly [...infer U, infer V] ? [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>] : Value extends readonly [...infer U, infer V] ? readonly [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>] : Value extends Array<infer U> ? Array<CamelCasedPropertiesDeep<U>> : Value extends ReadonlyArray<infer U> ? ReadonlyArray<CamelCasedPropertiesDeep<U>> : never;
+//#endregion
+export { BuiltIns, CamelCase, CamelCaseOptions, CamelCasedPropertiesDeep, IsLowerCase, IsNumeric, IsUpperCase, NonRecursiveType, Primitive, SplitWords, Trim, UnknownArray, UpperCaseCharacters, Whitespace, WordSeparators };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-DsiilEj-.d.ts","names":[],"sources":["../src/application/models/utilityTypes/primitive.d.ts","../src/application/models/utilityTypes/trim.d.ts","../src/application/models/utilityTypes/internal.d.ts","../src/application/models/utilityTypes/splitWords.d.ts","../src/application/models/utilityTypes/camelCase.d.ts","../src/application/models/utilityTypes/unknownArray.d.ts","../src/application/models/utilityTypes/camelCasedPropertiesDeep.d.ts"],"sourcesContent":["/**\n * Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).\n *\n * @category Type\n */\nexport type Primitive = null | undefined | string | number | boolean | symbol | bigint;\n","import type { Whitespace } from './internal';\n/**\n * Remove spaces from the left side.\n */\ntype TrimLeft<V extends string> = V extends `${Whitespace}${infer R}` ? TrimLeft<R> : V;\n/**\n * Remove spaces from the right side.\n */\ntype TrimRight<V extends string> = V extends `${infer R}${Whitespace}` ? TrimRight<R> : V;\n/**\n * Remove leading and trailing spaces from a string.\n * @example\n * ```\n * import type {Trim} from 'type-fest';\n *\n * Trim<' foo '>\n * //=> 'foo'\n * ```\n *\n * @category String\n * @category Template literal\n */\nexport type Trim<V extends string> = TrimLeft<TrimRight<V>>;\nexport {};\n","import { Primitive } from './primitive';\nimport { Trim } from './trim';\n/**\n * Matches any primitive, `void`, `Date`, or `RegExp` value.\n */\nexport type BuiltIns = Primitive | void | Date | RegExp;\n/**\n * Matches non-recursive types.\n */\nexport type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);\n/**\n * Returns a boolean for whether the string is numeric.\n *\n * This type is a workaround for [Microsoft/TypeScript#46109](https://github.com/microsoft/TypeScript/issues/46109#issuecomment-930307987).\n */\nexport type IsNumeric<T extends string> = T extends `${number}` ? Trim<T> extends T ? true : false : false;\n/**\n * Returns a boolean for whether the string is lowercased.\n */\nexport type IsLowerCase<T extends string> = T extends Lowercase<T> ? true : false;\n/**\n * Returns a boolean for whether the string is upper-cased.\n */\nexport type IsUpperCase<T extends string> = T extends Uppercase<T> ? true : false;\nexport type WordSeparators = '-' | '_' | Whitespace;\nexport type Whitespace = '\\u{9}' | '\\u{A}' | '\\u{B}' | '\\u{C}' | '\\u{D}' | '\\u{20}' | '\\u{85}' | '\\u{A0}' | '\\u{1680}' | '\\u{2000}' | '\\u{2001}' | '\\u{2002}' | '\\u{2003}' | '\\u{2004}' | '\\u{2005}' | '\\u{2006}' | '\\u{2007}' | '\\u{2008}' | '\\u{2009}' | '\\u{200A}' | '\\u{2028}' | '\\u{2029}' | '\\u{202F}' | '\\u{205F}' | '\\u{3000}' | '\\u{FEFF}';\nexport type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';\n","import type { IsLowerCase, IsNumeric, IsUpperCase, WordSeparators } from './internal';\ntype SkipEmptyWord<Word extends string> = Word extends '' ? [] : [Word];\ntype RemoveLastCharacter<Sentence extends string, Character extends string> = Sentence extends `${infer LeftSide}${Character}` ? SkipEmptyWord<LeftSide> : never;\n/**\n * Split a string (almost) like Lodash's `_.words()` function.\n *\n * - Split on each word that begins with a capital letter.\n * - Split on each {@link WordSeparators}.\n * - Split on numeric sequence.\n *\n * @example\n * ```\n * type Words0 = SplitWords<'helloWorld'>; // ['hello', 'World']\n * type Words1 = SplitWords<'helloWORLD'>; // ['hello', 'WORLD']\n * type Words2 = SplitWords<'hello-world'>; // ['hello', 'world']\n * type Words3 = SplitWords<'--hello the_world'>; // ['hello', 'the', 'world']\n * type Words4 = SplitWords<'lifeIs42'>; // ['life', 'Is', '42']\n * ```\n *\n * @internal\n * @category Change case\n * @category Template literal\n */\nexport type SplitWords<Sentence extends string, LastCharacter extends string = '', CurrentWord extends string = ''> = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}` ? FirstCharacter extends WordSeparators ? [\n    ...SkipEmptyWord<CurrentWord>,\n    ...SplitWords<RemainingCharacters>\n] : LastCharacter extends '' ? SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter> : [\n    false,\n    true\n] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? [\n    ...SkipEmptyWord<CurrentWord>,\n    ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>\n] : [\n    true,\n    false\n] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? [\n    ...SkipEmptyWord<CurrentWord>,\n    ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>\n] : [\n    true,\n    true\n] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? SplitWords<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`> : [\n    true,\n    true\n] extends [IsLowerCase<LastCharacter>, IsUpperCase<FirstCharacter>] ? [\n    ...SkipEmptyWord<CurrentWord>,\n    ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>\n] : [\n    true,\n    true\n] extends [IsUpperCase<LastCharacter>, IsLowerCase<FirstCharacter>] ? [\n    ...RemoveLastCharacter<CurrentWord, LastCharacter>,\n    ...SplitWords<RemainingCharacters, FirstCharacter, `${LastCharacter}${FirstCharacter}`>\n] : SplitWords<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`> : [...SkipEmptyWord<CurrentWord>];\nexport {};\n","import { SplitWords } from './splitWords';\n/**\n * CamelCase options.\n *\n * @see {@link CamelCase}\n */\nexport type CamelCaseOptions = {\n    /**\n     * Whether to preserved consecutive uppercase letter.\n     *\n     * @default true\n     */\n    preserveConsecutiveUppercase?: boolean;\n};\n/**\n * Convert an array of words to camel-case.\n */\ntype CamelCaseFromArray<Words extends string[], Options extends CamelCaseOptions, OutputString extends string = ''> = Words extends [infer FirstWord extends string, ...infer RemainingWords extends string[]] ? Options['preserveConsecutiveUppercase'] extends true ? `${Capitalize<FirstWord>}${CamelCaseFromArray<RemainingWords, Options>}` : `${Capitalize<Lowercase<FirstWord>>}${CamelCaseFromArray<RemainingWords, Options>}` : OutputString;\n/**\n * Convert a string literal to camel-case.\n *\n * This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.\n *\n * By default, consecutive uppercase letter are preserved. See {@link CamelCaseOptions.preserveConsecutiveUppercase preserveConsecutiveUppercase} option to change this behaviour.\n *\n * @example\n * ```\n * import type {CamelCase} from 'type-fest';\n *\n * // Simple\n *\n * const someVariable: CamelCase<'foo-bar'> = 'fooBar';\n *\n * // Advanced\n *\n * type CamelCasedProperties<T> = {\n * \t[K in keyof T as CamelCase<K>]: T[K]\n * };\n *\n * interface RawOptions {\n * \t'dry-run': boolean;\n * \t'full_family_name': string;\n * \tfoo: number;\n * \tBAR: string;\n * \tQUZ_QUX: number;\n * \t'OTHER-FIELD': boolean;\n * }\n *\n * const dbResult: CamelCasedProperties<RawOptions> = {\n * \tdryRun: true,\n * \tfullFamilyName: 'bar.js',\n * \tfoo: 123,\n * \tbar: 'foo',\n * \tquzQux: 6,\n * \totherField: false\n * };\n * ```\n *\n * @category Change case\n * @category Template literal\n */\nexport type CamelCase<Type, Options extends CamelCaseOptions = {\n    preserveConsecutiveUppercase: true;\n}> = Type extends string ? string extends Type ? Type : Uncapitalize<CamelCaseFromArray<SplitWords<Type extends Uppercase<Type> ? Lowercase<Type> : Type>, Options>> : Type;\nexport {};\n","/**\n * Represents an array with `unknown` value.\n *\n * Use case: You want a type that all arrays can be assigned to, but you don't care about the value.\n *\n * @example\n * ```\n * import type {UnknownArray} from 'type-fest';\n *\n * type IsArray<T> = T extends UnknownArray ? true : false;\n *\n * type A = IsArray<['foo']>;\n * //=> true\n *\n * type B = IsArray<readonly number[]>;\n * //=> true\n *\n * type C = IsArray<string>;\n * //=> false\n * ```\n *\n * @category Type\n * @category Array\n */\nexport type UnknownArray = readonly unknown[];\n","import { CamelCase, CamelCaseOptions } from './camelCase';\nimport { UnknownArray } from './unknownArray';\n/**\n * Convert object properties to camel case recursively.\n *\n * This can be useful when, for example, converting some API types from a different style.\n *\n * @see CamelCasedProperties\n * @see CamelCase\n *\n * @example\n * ```\n * import type {CamelCasedPropertiesDeep} 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: CamelCasedPropertiesDeep<UserWithFriends> = {\n * \tuserInfo: {\n * \t\tuserId: 1,\n * \t\tuserName: 'Tom',\n * \t},\n * \tuserFriends: [\n * \t\t{\n * \t\t\tuserId: 2,\n * \t\t\tuserName: 'Jerry',\n * \t\t},\n * \t\t{\n * \t\t\tuserId: 3,\n * \t\t\tuserName: 'Spike',\n * \t\t},\n * \t],\n * };\n * ```\n *\n * @category Change case\n * @category Template literal\n * @category Object\n */\nexport type CamelCasedPropertiesDeep<Value, Options extends CamelCaseOptions = {\n    preserveConsecutiveUppercase: true;\n}> = Value extends Function ? Value : Value extends UnknownArray ? CamelCasedPropertiesArrayDeep<Value> : Value extends Set<infer U> ? Set<CamelCasedPropertiesDeep<U, Options>> : {\n    [K in keyof Value as CamelCase<K, Options>]: CamelCasedPropertiesDeep<Value[K], Options>;\n};\ntype CamelCasedPropertiesArrayDeep<Value extends UnknownArray> = Value extends [] ? [] : Value extends [infer U, ...infer V] ? [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>] : Value extends readonly [infer U, ...infer V] ? readonly [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>] : Value extends readonly [...infer U, infer V] ? [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>] : Value extends readonly [...infer U, infer V] ? readonly [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>] : Value extends Array<infer U> ? Array<CamelCasedPropertiesDeep<U>> : Value extends ReadonlyArray<infer U> ? ReadonlyArray<CamelCasedPropertiesDeep<U>> : never;\nexport {};\n"],"mappings":";AAAA,IAAE,YAAA,CAAA,IAAA;;;;ACCF,IAAE,WAAA;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;AACF,IAAI,YAAY;CAAC;OAAW;OAAO;OAAA;OAAA;OAAA;CAAA;AACnC,IAAE,OAAA;CAAA;OAAA;OAAA;OAAA;CAAA;;;;ACDF,IAAE,WAAA;CAAA;OAAA;OAAA;OAAA;CAAA;AACF,IAAW,mBAAmB;CAAC;OAAW;OAAgB;CAAC;AAC3D,IAAE,YAAA;CAAA;OAAA;OAAA;OAAA;OAAA;CAAA;AACF,IAAW,cAAc;CAAC;OAAW;OAAS;OAAS;CAAA;AACvD,IAAE,cAAA;CAAA;OAAA;OAAA;OAAA;CAAA;AACF,IAAW,iBAAiB,CAAC,WAAC,WAAA;AAC9B,IAAE,aAAA,CAAA,IAAA;AACF,IAAW,sBAAsB,CAAC,IAAI;;;;ACRtC,IAAI,gBAAgB;CAAC;OAAW;OAAY;CAAK;AACjD,IAAI,sBAAsB;CAAC;OAAW;OAAgB;OAAiB;OAAgB;CAAc;AACrG,IAAE,aAAA;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;;;;ACFF,IAAE,mBAAA,CAAA,IAAA;AACF,IAAI,qBAAgB;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;AACpB,IAAC,YAAA;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;;;;ACHD,IAAE,eAAA,CAAA,IAAA;;;;ACEF,IAAE,2BAAA;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;AACF,IAAI,gCAAgC;CAAC;OAAW;OAAM;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA"}

package/dist/index-RcVcRKH7.d.cts

@@ -0,0 +1 @@
+export {};

package/dist/index-hdbCEjYy.d.cts

@@ -0,0 +1,39 @@
+import { PageVisitCategory } from "@spiffy-ai/commerce-api-client";
+
+//#region src/application/models/variantInfo/plpInfo.d.ts
+interface PLPInfo {
+  plpId: string;
+}
+//#endregion
+//#region src/application/models/variantInfo/pageVisitInfo.d.ts
+interface PageVisitInfo {
+  url: string;
+  pageVisitCategory: PageVisitCategory;
+}
+//#endregion
+//#region src/application/models/variantInfo/productInfo.d.ts
+interface ProductInfo {
+  productId: string;
+  parentProductId?: string;
+  url?: string;
+}
+//#endregion
+//#region src/application/models/variantInfo/variantInfo.d.ts
+type VariantType = 'pdp' | 'plp' | 'page_visit';
+type VariantInfo = PDPVariantInfo | PLPVariantInfo | PageVisitVariantInfo;
+type PDPVariantInfo = {
+  variantId: string;
+  variant: 'pdp';
+} & ProductInfo;
+type PLPVariantInfo = {
+  variantId: string;
+  variant: 'plp';
+  url?: string;
+} & PLPInfo;
+type PageVisitVariantInfo = {
+  variantId: string;
+  variant: 'page_visit';
+} & PageVisitInfo;
+//#endregion
+export { PDPVariantInfo, PLPInfo, PLPVariantInfo, PageVisitInfo, PageVisitVariantInfo, ProductInfo, VariantInfo, VariantType };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/interceptors/index.cjs

@@ -0,0 +1,4 @@
+require('../types-o3zWarRp.cjs');
+const require_useMessageInterceptor = require('../useMessageInterceptor-C9p9No1n.cjs');
+
+exports.useMessageInterceptor = require_useMessageInterceptor.useMessageInterceptor;