@elevateab/sdk 1.2.0 → 1.2.2

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+export { a as ElevateAnalytics, E as ElevateHydrogenAnalyticsProps, U as UseAnalyticsHook } from './ElevateAnalytics-Cp5iR7dJ.js';
 
 interface BackendConfig {
     allTests: {
@@ -7,33 +8,89 @@ interface BackendConfig {
     selectors?: {
         selectorsV2?: unknown[];
     };
+    /**
+     * Indicates if the subscription is paused/stopped.
+     * When true, SDK should not initialize and just render children.
+     */
+    subscriptionPaused?: boolean;
+    /**
+     * Human-readable message about subscription status.
+     */
+    subscriptionMessage?: string;
 }
-interface BackendTest {
-    data: {
-        name: string;
-        isLive: boolean;
-        settings?: Record<string, unknown>;
-        type: string;
-        filters?: unknown[];
-        isPersonalization?: boolean;
-        testTrafficPercentage?: number;
-        handles?: string[];
-        productIds?: number[];
-        defaultVariants?: Record<string, number>;
+interface BackendTestData {
+    name: string;
+    isLive: boolean;
+    settings?: Record<string, unknown>;
+    type: string;
+    filters?: unknown[];
+    isPersonalization?: boolean;
+    testTrafficPercentage?: number;
+    handles?: string[];
+    productIds?: string[];
+    defaultVariants?: Record<string, string>;
+    currencies?: string[];
+    links?: string[];
+    pathnames?: string[];
+    excludePathnames?: string[];
+    redirectBehavior?: string;
+    variantIds?: string[];
+    options?: string[];
+    shippingZones?: {
+        countriesToInclude?: string[];
+        countriesToExclude?: string[];
     };
-    [variationId: string]: BackendVariation | BackendTest["data"];
+}
+interface BackendTest {
+    data: BackendTestData;
+    [variationId: string]: BackendVariation | BackendTestData;
 }
 interface BackendVariation {
     variationName: string;
     trafficPercentage: number;
     isDone?: boolean;
     isControl?: boolean;
-    id?: number;
+    id?: string;
     productTitle?: string;
     handle?: string;
     price?: string;
     link?: string;
     productVariants?: unknown[];
+    originalProductHandle?: string;
+    prices?: Record<string, {
+        main: string;
+        price: Record<string, string>;
+        compare: Record<string, string | null>;
+    }>;
+    images?: Array<{
+        productId: string;
+        handle: string;
+        index: number;
+        originalSrc: string;
+        originalFilename?: string;
+        newSrc: string;
+        newFilename?: string;
+        isOriginalImage?: boolean;
+    }>;
+    customCode?: {
+        id: string;
+        js: string;
+        css: string;
+        pathnames: string[];
+        excludePathnames?: string[];
+    };
+    splitUrlTestLinks?: Record<string, string>;
+    content?: Record<string, unknown>;
+    checkout?: {
+        banner?: {
+            title: string;
+            status: string;
+            spacing: string;
+            description: string;
+            headingSize: string;
+            descriptionSize: string;
+        };
+    };
 }
 interface Test {
     testId: string;
@@ -47,21 +104,575 @@ interface Variation {
     name: string;
     weight: number;
     isControl?: boolean;
-    productId?: number;
+    productId?: string;
     handle?: string;
     price?: string;
+    /** Convenience flag: true if this is variation A (index 0) */
+    isA?: boolean;
+    /** Convenience flag: true if this is variation B (index 1) */
+    isB?: boolean;
+    /** Convenience flag: true if this is variation C (index 2) */
+    isC?: boolean;
+    /** Convenience flag: true if this is variation D (index 3) */
+    isD?: boolean;
 }
 interface ElevateConfig {
     tests: Test[];
     selectors?: unknown;
 }
 interface ElevateProviderProps {
+    /**
+     * Shopify store ID (e.g., "mystore.myshopify.com")
+     * @required
+     */
     storeId: string;
+    /**
+     * Cart object from Shopify loader (for Analytics.Provider)
+     * @example data.cart from root loader
+     */
+    cart?: unknown;
+    /**
+     * Shop object from Shopify loader (for Analytics.Provider)
+     * @example data.shop from root loader
+     */
+    shop?: unknown;
+    /**
+     * Consent object from Shopify loader (for Analytics.Provider)
+     * @example data.consent from root loader
+     */
+    consent?: unknown;
+    /**
+     * Enable localized path detection (e.g., /en-us/, /fr-ca/)
+     * Only set to true if your homepage uses path-based localization
+     * @default false
+     */
+    hasLocalizedPaths?: boolean;
+    /**
+     * Storefront access token for cart attribute updates
+     */
+    storefrontAccessToken?: string;
+    /**
+     * Custom CloudFlare Worker URL (defaults to production endpoint)
+     */
+    workerUrl?: string;
+    /**
+     * Custom CloudFlare Worker URL for orders (defaults to production orders endpoint)
+     */
+    ordersWorkerUrl?: string;
+    /**
+     * Enable flicker prevention - hides content until test assignment is complete
+     * Prevents users from seeing content flash/change when variants load
+     * @default false
+     */
+    preventFlickering?: boolean;
+    /**
+     * Timeout in milliseconds for flicker prevention failsafe
+     * Content will show after this time even if assignment isn't complete
+     * @default 3000
+     */
+    flickerTimeout?: number;
     children: React.ReactNode;
 }
 interface ElevateContextValue {
     config: ElevateConfig | null;
+    /** Store ID for tracking */
+    storeId: string;
+    /** Storefront access token for cart attribute updates (optional) */
+    storefrontAccessToken?: string;
+    /** Whether preview mode is active */
+    isPreviewMode?: boolean;
+    /** Current preview test ID if in preview mode */
+    previewTestId?: string | null;
+    /** User's detected country code */
+    countryCode?: string | null;
+}
+type ExperimentStatus = "draft" | "running" | "paused" | "completed";
+interface ElevateAnalyticsProps {
+    /**
+     * Shopify store ID (e.g., "mystore.myshopify.com")
+     * @required
+     */
+    storeId: string;
+    /**
+     * Enable localized path detection (e.g., /en-us/, /fr-ca/)
+     * @default false
+     */
+    hasLocalizedPaths?: boolean;
+    /**
+     * Storefront access token for cart attribute updates
+     */
+    storefrontAccessToken?: string;
+    /**
+     * Custom CloudFlare Worker URL (defaults to production endpoint)
+     */
+    workerUrl?: string;
+    /**
+     * Custom CloudFlare Worker URL for orders (defaults to production orders endpoint)
+     */
+    ordersWorkerUrl?: string;
+}
+/**
+ * A/B test assignment included in all events
+ */
+interface TestAssignment {
+    test_id: string;
+    variant_id: string;
+}
+/**
+ * Product info for cart items
+ */
+interface CartItemInput {
+    /** Shopify Product ID (numeric, not GID) */
+    productId: string;
+    /** Shopify Product Variant ID (numeric, not GID) */
+    variantId: string;
+    /** Product vendor/brand name */
+    productVendor?: string;
+    /** Item price (single unit) */
+    productPrice?: number;
+    /** Quantity in cart */
+    productQuantity?: number;
+    /** Product SKU */
+    productSku?: string;
+    /** Discount amount on this item */
+    totalDiscount?: number;
+}
+/**
+ * Note attribute for checkout
+ */
+interface NoteAttribute {
+    key: string;
+    value: string;
+}
+/**
+ * Base configuration for all tracking events.
+ *
+ * Note: If you call `initAnalytics()` first (or use ElevateProvider which does this automatically),
+ * you don't need to pass storeId to individual tracking calls.
+ */
+interface BaseTrackingConfig {
+    /**
+     * Shopify store ID (e.g., "mystore.myshopify.com")
+     * Optional if initAnalytics() was called or ElevateProvider is used.
+     */
+    storeId?: string;
+    /**
+     * Enable localized path detection (e.g., /en-us/, /fr-ca/)
+     * @default false
+     */
+    hasLocalizedPaths?: boolean;
+    /**
+     * Cart/shop currency code (e.g., "USD", "EUR")
+     * If not provided, will try to detect from Shopify or omit.
+     */
+    currency?: string;
+    /**
+     * Custom CloudFlare Worker URL (optional)
+     */
+    workerUrl?: string;
+}
+/**
+ * Parameters for tracking a page view
+ * @example After initAnalytics() or inside ElevateProvider (recommended)
+ * ```ts
+ * await trackPageView(); // No params needed!
+ * await trackPageView({ currency: "USD" }); // Optional currency
+ * ```
+ * @example Standalone (without init)
+ * ```ts
+ * await trackPageView({ storeId: "mystore.myshopify.com" });
+ * ```
+ */
+interface TrackPageViewParams extends BaseTrackingConfig {
+}
+/**
+ * Parameters for tracking a product view
+ * @example After initAnalytics() or inside ElevateProvider (recommended)
+ * ```ts
+ * await trackProductView({
+ *   productId: "123456789",
+ *   productPrice: 99.99,
+ * });
+ * ```
+ * @example With all optional fields
+ * ```ts
+ * await trackProductView({
+ *   productId: "123456789",
+ *   productVendor: "Nike",
+ *   productPrice: 99.99,
+ *   productSku: "NIKE-001",
+ *   currency: "USD",
+ * });
+ * ```
+ */
+interface TrackProductViewParams extends BaseTrackingConfig {
+    /**
+     * Shopify Product ID (numeric string, not GID)
+     * @required
+     */
+    productId: string;
+    /** Product vendor/brand name */
+    productVendor?: string;
+    /** Product price */
+    productPrice?: number;
+    /** Product SKU */
+    productSku?: string;
+}
+/**
+ * Parameters for tracking add to cart
+ * @example After initAnalytics() or inside ElevateProvider (recommended)
+ * ```ts
+ * await trackAddToCart({
+ *   productId: "123456789",
+ *   variantId: "987654321",
+ *   productPrice: 99.99,
+ *   productQuantity: 1,
+ * });
+ * ```
+ * @example With cart ID for automatic attribute updates
+ * ```ts
+ * await trackAddToCart({
+ *   productId: "123456789",
+ *   variantId: "987654321",
+ *   productPrice: 99.99,
+ *   productQuantity: 1,
+ *   cartId: "gid://shopify/Cart/abc123",
+ * });
+ * ```
+ */
+interface TrackAddToCartParams extends BaseTrackingConfig {
+    /**
+     * Shopify Product ID (numeric string, not GID)
+     * @required
+     */
+    productId: string;
+    /**
+     * Shopify Product Variant ID (numeric string, not GID)
+     * @required
+     */
+    variantId: string;
+    /** Product vendor/brand name */
+    productVendor?: string;
+    /** Product price (single unit) */
+    productPrice?: number;
+    /** Quantity being added */
+    productQuantity?: number;
+    /** Product SKU */
+    productSku?: string;
+    /**
+     * Cart ID (GID or token) - if provided, cart attributes will be updated automatically
+     * @example "gid://shopify/Cart/abc123" or "abc123"
+     */
+    cartId?: string;
+    /**
+     * Storefront Access Token - REQUIRED if cartId is provided
+     * ✅ Safe to use client-side - this is a public token
+     */
+    storefrontAccessToken?: string;
+}
+/**
+ * Parameters for tracking remove from cart
+ * @example
+ * ```ts
+ * await trackRemoveFromCart({
+ *   productId: "123456789",
+ *   variantId: "987654321",
+ *   productQuantity: 1,
+ * });
+ * ```
+ */
+interface TrackRemoveFromCartParams extends BaseTrackingConfig {
+    /**
+     * Shopify Product ID (numeric string, not GID)
+     * @required
+     */
+    productId: string;
+    /**
+     * Shopify Product Variant ID (numeric string, not GID)
+     * @required
+     */
+    variantId: string;
+    /** Product vendor/brand name */
+    productVendor?: string;
+    /** Product price (single unit) */
+    productPrice?: number;
+    /** Quantity being removed */
+    productQuantity?: number;
+    /** Product SKU */
+    productSku?: string;
+}
+/**
+ * Parameters for tracking cart view
+ * @example
+ * ```ts
+ * await trackCartView({
+ *   cartTotalPrice: 199.98,
+ *   cartTotalQuantity: 2,
+ *   cartItems: [{ productId: "123", variantId: "456", productPrice: 99.99 }],
+ * });
+ * ```
+ */
+interface TrackCartViewParams extends BaseTrackingConfig {
+    /** Total cart price */
+    cartTotalPrice?: number;
+    /** Total items in cart */
+    cartTotalQuantity?: number;
+    /** Cart line items */
+    cartItems?: CartItemInput[];
+}
+/**
+ * Parameters for tracking search submission
+ * @example
+ * ```ts
+ * await trackSearchSubmitted({ searchQuery: "running shoes" });
+ * ```
+ */
+interface TrackSearchSubmittedParams extends BaseTrackingConfig {
+    /**
+     * Search query string
+     * @required
+     */
+    searchQuery: string;
+}
+/**
+ * Parameters for tracking checkout started
+ * @example
+ * ```ts
+ * await trackCheckoutStarted({
+ *   cartTotalPrice: 109.98,
+ *   cartItems: [...],
+ * });
+ * ```
+ */
+interface TrackCheckoutStartedParams extends BaseTrackingConfig {
+    /** Total checkout price (including shipping, tax) */
+    cartTotalPrice?: number;
+    /** Subtotal (before shipping, tax) */
+    cartSubtotalPrice?: number;
+    /** Shipping cost */
+    cartShippingPrice?: number;
+    /** Tax amount */
+    cartTaxAmount?: number;
+    /** Total discount applied */
+    cartDiscountAmount?: number;
+    /** Shopify Customer ID */
+    customerId?: string;
+    /** Checkout line items */
+    cartItems?: CartItemInput[];
+}
+/**
+ * Parameters for tracking checkout completed (order placed)
+ * NOTE: This sends to the orders worker endpoint
+ * @example
+ * ```ts
+ * await trackCheckoutCompleted({
+ *   orderId: "order_123456",
+ *   cartTotalPrice: 109.98,
+ *   cartItems: [...],
+ * });
+ * ```
+ */
+interface TrackCheckoutCompletedParams extends Omit<BaseTrackingConfig, "workerUrl"> {
+    /**
+     * Shopify Order ID
+     * @required
+     */
+    orderId: string;
+    /** Total checkout price (including shipping, tax) */
+    cartTotalPrice?: number;
+    /** Subtotal (before shipping, tax) */
+    cartSubtotalPrice?: number;
+    /** Shipping cost */
+    cartShippingPrice?: number;
+    /** Tax amount */
+    cartTaxAmount?: number;
+    /** Total discount applied */
+    cartDiscountAmount?: number;
+    /** Shopify Customer ID */
+    customerId?: string;
+    /** Whether this is customer's first order */
+    isFirstOrder?: boolean;
+    /** Order note attributes (for A/B test attribution) */
+    noteAttributes?: NoteAttribute[];
+    /** Checkout line items */
+    cartItems?: CartItemInput[];
+    /**
+     * Custom orders worker URL (optional)
+     * Note: Uses different endpoint than other events
+     */
+    ordersWorkerUrl?: string;
+}
+/**
+ * Parameters for auto page view tracking hook
+ * @example After initAnalytics() or inside ElevateProvider
+ * ```ts
+ * // In your layout component
+ * usePageViewTracking({ enabled: true });
+ * ```
+ * @example With Next.js usePathname (recommended)
+ * ```ts
+ * const pathname = usePathname();
+ * usePageViewTracking({ pathname, enabled: true });
+ * ```
+ */
+interface UsePageViewTrackingParams extends BaseTrackingConfig {
+    /**
+     * Enable/disable tracking
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Cart item as sent to the worker
+ * @internal
+ */
+interface CartItemPayload {
+    product_id: string;
+    variant_id: string;
+    product_vendor?: string;
+    product_price: number | null;
+    product_quantity: number | null;
+    product_sku?: string;
+    total_discount?: number | null;
+    vendor?: string;
+    total_price?: number | null;
+    quantity?: number | null;
+    sku?: string;
 }
+/**
+ * Full event payload sent to CloudFlare Worker
+ * @internal - Users don't need to construct this directly
+ */
+interface EventPayload {
+    pixel_event_id: string;
+    shop_name: string;
+    timestamp: string;
+    event_type: string;
+    client_id?: string;
+    visitor_id: string;
+    session_id: string;
+    cart_token: string | null;
+    page_url: string;
+    page_pathname: string;
+    page_search: string;
+    referrer_url: string;
+    referrer_source: string;
+    previous_page: string;
+    page_entry: string;
+    page_entry_path: string;
+    page_type: string;
+    utm_medium: string;
+    utm_source: string;
+    utm_campaign: string;
+    utm_content: string;
+    utm_term: string;
+    gclid: string;
+    fbclid: string;
+    pins_campaign_id?: string;
+    epik?: string;
+    browser_info: string;
+    os_info: string;
+    device_type: string;
+    language: string;
+    root_route: string;
+    user_agent: string;
+    user_agent_no_browser?: string;
+    is_first_visit?: boolean;
+    shopify_country?: string;
+    cart_currency?: string;
+    ab_test_assignments: TestAssignment[];
+    ab_test_views: TestAssignment[];
+    is_first_order?: boolean | null;
+    product_id?: string;
+    product_vendor?: string;
+    product_price?: number | null;
+    product_sku?: string;
+    variant_id?: string;
+    product_quantity?: number | null;
+    cart_total_price?: number | null;
+    cart_subtotal_price?: number | null;
+    cart_total_quantity?: number | null;
+    cart_shipping_price?: number | null;
+    cart_tax_amount?: number | null;
+    cart_discount_amount?: number | null;
+    cart_items?: CartItemPayload[];
+    search_query?: string;
+    order_id?: string;
+    customer_id?: string;
+    note_attributes?: NoteAttribute[];
+    token?: string;
+    exclude?: boolean;
+}
+/**
+ * Options for updating cart attributes
+ *
+ * ## For Hydrogen Stores
+ * Use your built-in storefront client with `getCartAttributesPayload()` instead.
+ *
+ * ## For Next.js / Other Stores
+ * You MUST provide `storefrontAccessToken`.
+ *
+ * ✅ **The Storefront Access Token is SAFE to use client-side!**
+ *
+ * It's a PUBLIC token that Shopify specifically designed for browser use.
+ * It can only:
+ * - Read products, collections, pages
+ * - Create and update carts
+ * - Create checkouts
+ *
+ * It CANNOT:
+ * - Delete products
+ * - Access admin functions
+ * - Read orders or customer PII
+ * - Do anything destructive
+ *
+ * Get your token from: Shopify Admin → Settings → Apps → Develop apps
+ *
+ * @example
+ * ```ts
+ * // Next.js - safe to use client-side!
+ * await updateCartAttributes(cartId, {
+ *   storefrontAccessToken: process.env.NEXT_PUBLIC_STOREFRONT_TOKEN
+ * });
+ * ```
+ */
+interface CartAttributesOptions {
+    /**
+     * Custom Storefront API URL
+     *
+     * Only needed if you have a custom proxy or different API endpoint.
+     * If provided, storefrontAccessToken may not be required (if your proxy handles auth).
+     *
+     * @default "https://{storeDomain}/api/2025-01/graphql.json"
+     */
+    storefrontApiUrl?: string;
+    /**
+     * Shopify Storefront Access Token
+     *
+     * ⚠️ **Required for Next.js and non-Hydrogen stores**
+     *
+     * ✅ Safe to expose client-side - this is a PUBLIC token with limited permissions.
+     *
+     * Get it from: Shopify Admin → Settings → Apps → Develop apps → API credentials
+     *
+     * @example "shpat_xxxxxxxxxxxxxxxxxxxxx"
+     */
+    storefrontAccessToken?: string;
+}
+/**
+ * Cart attribute input for GraphQL mutation
+ *
+ * These key-value pairs are attached to the Shopify cart for order attribution.
+ */
+interface CartAttributeInput {
+    /** Attribute key (e.g., "_eabTestsList") */
+    key: string;
+    /** Attribute value (JSON string for complex data) */
+    value: string;
+}
+/**
+ * @deprecated Use TrackPageViewParams instead
+ */
 interface TrackingEvent {
     experimentId: string;
     variantId: string;
@@ -69,7 +680,6 @@ interface TrackingEvent {
     timestamp: number;
     metadata?: Record<string, unknown>;
 }
-type ExperimentStatus = "draft" | "running" | "paused" | "completed";
 
 /**
  * Assigns a variant based on weighted distribution
@@ -83,39 +693,829 @@ declare function calculateRevenueLift(controlRevenue: number, variantRevenue: nu
     confidence: number;
 };
 
-interface ExperimentProps {
-    testId: string;
-    userId: string;
-    onVariantAssigned?: (variant: Variation) => void;
-    children?: React.ReactNode;
+/**
+ * Cookie and Session Storage utilities
+ */
+/**
+ * Generate a UUID v4
+ */
+declare function uuidv4(): string;
+/**
+ * Set a cookie with 1 year expiration
+ */
+declare function setCookie(name: string, value: string): void;
+/**
+ * Get a cookie value by name
+ */
+declare function getCookie(name: string): string | null;
+/**
+ * Get a JSON-parsed cookie value
+ */
+declare function getJsonCookie<T = Record<string, unknown>>(name: string): T | null;
+/**
+ * Delete a cookie
+ */
+declare function deleteCookie(cookieName: string): void;
+/**
+ * Set a session storage item
+ */
+declare function setSessionItem(name: string, value: unknown): void;
+/**
+ * Get a session storage item
+ */
+declare function getSessionItem(name: string): string | null;
+/**
+ * Get a JSON-parsed session storage item
+ */
+declare function getJsonSessionItem<T = unknown>(name: string): T | null;
+/**
+ * Initialize visitor ID - creates eabUserId cookie if it doesn't exist
+ */
+declare function initializeVisitorId(): string;
+/**
+ * Get or create visitor ID
+ */
+declare function getVisitorId(): string;
+/**
+ * Initialize session ID - creates eabSessionId in sessionStorage if it doesn't exist
+ */
+declare function initializeSessionId(): string;
+/**
+ * Get or create session ID
+ */
+declare function getSessionId(): string;
+/**
+ * Store referrer and entry page data in sessionStorage
+ */
+declare function setReferrerData(referrer: string, entryPage: string): void;
+/**
+ * Get referrer data from sessionStorage
+ */
+declare function getReferrerData(): {
+    referrer: string;
+    entryPage: string;
+};
+
+/**
+ * Variant assignment logic
+ */
+
+interface TestList {
+    [testId: string]: string;
 }
 /**
- * React component for A/B test experiments
- * Fetches config from ElevateProvider context based on testId
+ * Get the test list from ABTL cookie
  */
-declare function Experiment({ testId, userId, onVariantAssigned, children, }: ExperimentProps): React.JSX.Element | null;
-interface VariantDisplayProps {
-    variantId: string;
-    children: React.ReactNode;
+declare function getTestList(): TestList;
+/**
+ * Save test list to ABTL cookie
+ */
+declare function saveTestList(testList: TestList): void;
+/**
+ * Get assigned variant for a test from ABTL cookie
+ */
+declare function getAssignedVariant(testId: string): string | null;
+/**
+ * Assign and persist variant for a test
+ */
+declare function assignAndPersistVariant(testId: string, test: Test, userId: string): Variation | null;
+/**
+ * Check if test should be shown based on traffic percentage
+ */
+declare function shouldShowTest(test: Test): boolean;
+
+/**
+ * Tracking utilities for views and participation
+ */
+/**
+ * Track unique view for a test (ABAU cookie)
+ */
+declare function trackUniqueView(testId: string): void;
+/**
+ * Track session view for a test (ABAV session storage)
+ */
+declare function trackSessionView(testId: string): void;
+/**
+ * Track both unique and session views
+ */
+declare function trackViews(testId: string): void;
+/**
+ * Check if test has been viewed in this session
+ */
+declare function hasSessionView(testId: string): boolean;
+/**
+ * Check if test has a unique view
+ */
+declare function hasUniqueView(testId: string): boolean;
+
+/**
+ * Condition checking utilities for targeting and filtering
+ */
+/**
+ * Detect device type
+ */
+declare function getDeviceType(): "desktop" | "tablet" | "mobile";
+/**
+ * Check if Facebook in-app browser
+ */
+declare function checkFacebookBrowser(): boolean;
+/**
+ * Check if Instagram in-app browser
+ */
+declare function checkInstagramBrowser(): boolean;
+/**
+ * Check if TikTok in-app browser
+ */
+declare function checkTikTokBrowser(): boolean;
+/**
+ * Check if Pinterest in-app browser
+ */
+declare function checkPinterestBrowser(): boolean;
+/**
+ * Get traffic source
+ */
+declare function getTrafficSource(): string;
+
+/**
+ * Preview Mode Utilities
+ *
+ * Enables QA/preview functionality for A/B tests via URL parameters.
+ *
+ * URL Format:
+ * ?eabUserPreview=true&abtid=<test_id>&eab_tests=<shortid>_<variation>_<seen>
+ *
+ * Example:
+ * https://store.com/?eabUserPreview=true&abtid=b6e2ecb8-e35a-450e-ae49-bdc560cf0fd7&eab_tests=f0fd7_29913_1
+ */
+/**
+ * Preview mode state
+ */
+interface PreviewState {
+    /** Whether preview mode is active */
+    isPreview: boolean;
+    /** The test ID being previewed (full UUID or short ID) */
+    previewTestId: string | null;
+    /** Forced test assignments from URL params */
+    forcedAssignments: Record<string, string>;
+    /** Tests that have been marked as "seen" in preview */
+    previewedViews: Record<string, boolean>;
+}
+/**
+ * Get preview state from URL parameters and cookies
+ */
+declare function getPreviewState(): PreviewState;
+/**
+ * Check if a test matches the preview test ID
+ * Supports both full UUID and short ID (last 5 chars) matching
+ */
+declare function isPreviewTest(testId: string, previewTestId: string | null): boolean;
+/**
+ * Get forced variation for a test in preview mode
+ * Returns null if no forced assignment exists
+ */
+declare function getPreviewVariation(testId: string, previewState: PreviewState): string | null;
+/**
+ * Build eab_tests URL parameter string from test assignments
+ * Used for sharing preview URLs with Facebook/Instagram traffic
+ */
+declare function buildEabTestsParam(testAssignments: Record<string, string>, viewedTests: Record<string, boolean>): string;
+/**
+ * Update URL with test parameters for social media browsers (FB/IG/TikTok)
+ * These browsers often lose cookies, so we persist test assignments in URL
+ */
+declare function updateUrlWithTestParams(testAssignments: Record<string, string>, viewedTests: Record<string, boolean>, visitorId?: string): void;
+/**
+ * Clear preview mode
+ */
+declare function clearPreviewMode(): void;
+/**
+ * Check if current session is in preview mode
+ */
+declare function isInPreviewMode(): boolean;
+
+/**
+ * Geo-targeting Utilities
+ *
+ * Provides country detection and geo-based targeting for A/B tests.
+ */
+/**
+ * Geo-location data
+ */
+interface GeoLocation {
+    /** ISO 3166-1 alpha-2 country code (e.g., "US", "GB", "CA") */
+    country: string | null;
+    /** Region/state code (if available) */
+    region?: string | null;
+    /** City name (if available) */
+    city?: string | null;
+}
+/**
+ * Get the user's country code from various sources
+ * Priority: URL param > Shopify localization > our cookie > localStorage
+ */
+declare function getCountryCode(): string | null;
+/**
+ * Get full geo-location data
+ */
+declare function getGeoLocation(): GeoLocation;
+/**
+ * Set the user's country code (for manual override or after geo detection)
+ */
+declare function setCountryCode(countryCode: string): void;
+/**
+ * Set full geo-location data
+ */
+declare function setGeoLocation(geo: GeoLocation): void;
+/**
+ * Check if user's country matches a list of allowed countries
+ */
+declare function isCountryIncluded(allowedCountries: string[], userCountry?: string | null): boolean;
+/**
+ * Check if user's country is in an excluded list
+ */
+declare function isCountryExcluded(excludedCountries: string[], userCountry?: string | null): boolean;
+/**
+ * Check if user matches geo-targeting rules
+ * Returns true if user should be included in the test
+ */
+declare function matchesGeoTargeting(rules: {
+    includeCountries?: string[];
+    excludeCountries?: string[];
+}): boolean;
+/**
+ * Common country code constants for convenience
+ */
+declare const COUNTRIES: {
+    readonly US: "US";
+    readonly CA: "CA";
+    readonly GB: "GB";
+    readonly AU: "AU";
+    readonly DE: "DE";
+    readonly FR: "FR";
+    readonly JP: "JP";
+    readonly MX: "MX";
+    readonly BR: "BR";
+    readonly IN: "IN";
+};
+/**
+ * Region groupings for common use cases
+ */
+declare const REGIONS: {
+    readonly NORTH_AMERICA: readonly ["US", "CA", "MX"];
+    readonly EUROPE: readonly ["GB", "DE", "FR", "IT", "ES", "NL", "BE", "AT", "CH", "PL", "SE", "NO", "DK", "FI", "IE", "PT"];
+    readonly APAC: readonly ["AU", "NZ", "JP", "KR", "SG", "HK", "TW", "TH", "MY", "PH", "ID", "VN", "IN"];
+    readonly LATAM: readonly ["MX", "BR", "AR", "CL", "CO", "PE"];
+};
+
+/**
+ * Anti-Flicker Utilities
+ *
+ * Prevents visual flickering during A/B test assignment by hiding content
+ * until the variant is determined. Uses a CSS-based approach for performance.
+ *
+ * Note: Called "preventFlickering" in our API to differentiate from competitors.
+ */
+/**
+ * Inject the flicker prevention CSS styles
+ * This should be called as early as possible (ideally in <head>)
+ */
+declare function injectFlickerStyles(timeout?: number): void;
+/**
+ * Hide the page/element to prevent flicker
+ * Call this before test assignment begins
+ */
+declare function hideForFlicker(selector?: string): void;
+/**
+ * Show the page/element after test assignment is complete
+ * Call this after variant is determined
+ */
+declare function revealAfterFlicker(selector?: string): void;
+/**
+ * Setup flicker prevention with automatic reveal
+ * Returns a function to call when assignment is complete
+ *
+ * @param selector - CSS selector for element to hide (default: "body")
+ * @param timeout - Maximum time to wait before revealing (default: 3000ms)
+ * @returns Function to call when test assignment is complete
+ *
+ * @example
+ * ```tsx
+ * // In your app initialization
+ * const reveal = setupFlickerPrevention();
+ *
+ * // After test assignment
+ * reveal();
+ * ```
+ */
+declare function setupFlickerPrevention(selector?: string, timeout?: number): () => void;
+/**
+ * Remove all flicker prevention styles and classes
+ * Useful for cleanup or when disabling the feature
+ */
+declare function cleanupFlickerPrevention(): void;
+/**
+ * Check if flicker prevention is currently active
+ */
+declare function isFlickerPreventionActive(): boolean;
+/**
+ * Script snippet for inline injection in <head>
+ * Use this when you need synchronous flicker prevention before React hydrates
+ *
+ * @example
+ * ```tsx
+ * // In your _document.tsx or layout.tsx
+ * <script dangerouslySetInnerHTML={{ __html: getFlickerPreventionScript() }} />
+ * ```
+ */
+declare function getFlickerPreventionScript(timeout?: number): string;
+
+/**
+ * Analytics utilities for parsing and extracting data from events
+ */
+/**
+ * Sanitize string values to prevent XSS
+ */
+declare function sanitizeString(value: unknown): string;
+/**
+ * Round number to 2 decimal places
+ */
+declare function roundToTwo(value: unknown): number | null;
+/**
+ * Extract product ID from Shopify GID
+ */
+declare function extractProductId(gid: string | undefined): string | null;
+/**
+ * Extract product variant ID from Shopify GID
+ */
+declare function extractProductVariantId(gid: string | undefined): string | null;
+/**
+ * Extract cart token from Shopify GID
+ */
+declare function extractCartToken(gid: string | undefined | null): string | null;
+/**
+ * Clean cart token by removing query parameters
+ */
+declare function cleanCartToken(cartToken: string | null | undefined): string | null;
+/**
+ * Check if Facebook or Instagram browser
+ */
+declare function checkFacebookInstagramBrowser(userAgent: string): boolean;
+/**
+ * Parse and extract analytics view data from referrer, entry page, and user agent
+ */
+interface ParsedViewData {
+    referrer_source: string;
+    browser_info: string;
+    os_info: string;
+    device_type: string;
+    page_entry_path: string;
+    utm_medium: string;
+    utm_source: string;
+    utm_campaign: string;
+    utm_content: string;
+    utm_term: string;
+    referrer_url: string;
+    gclid: string;
+    fbclid: string;
+    pins_campaign_id: string;
+    epik: string;
 }
-declare function VariantDisplay({ variantId, children }: VariantDisplayProps): React.JSX.Element | null;
-declare function useExperiment(testId: string, userId: string): {
+declare function parseAddViewData(params: {
+    referrer?: string;
+    entryPage?: string;
+    userAgent?: string;
+}): ParsedViewData;
+/**
+ * Get page type from pathname
+ */
+declare function getPageTypeFromPathname(path: string, hasLocalizedPaths?: boolean): string;
+/**
+ * Check if visitor ID is in URL params
+ */
+declare function checkVisitorIdParams(searchParams: string): string | false;
+/**
+ * Get user agent string without browser info
+ * Used for more consistent user fingerprinting
+ */
+declare function getUserAgentNoBrowser(userAgent: string): string;
+
+/**
+ * Shopify-specific utilities
+ */
+/**
+ * Extract numeric ID from a Shopify Global ID (GID).
+ *
+ * Shopify uses GIDs like "gid://shopify/Product/123456789" or "gid://shopify/ProductVariant/987654321".
+ * This utility extracts the numeric ID portion.
+ *
+ * @param gid - Shopify Global ID or numeric ID string
+ * @returns The numeric ID portion (e.g., "123456789")
+ *
+ * @example
+ * ```ts
+ * extractShopifyId("gid://shopify/Product/123456789"); // "123456789"
+ * extractShopifyId("gid://shopify/ProductVariant/987654321"); // "987654321"
+ * extractShopifyId("gid://shopify/Cart/abc123"); // "abc123"
+ * extractShopifyId("123456789"); // "123456789" (already numeric)
+ * ```
+ */
+declare function extractShopifyId(gid: string | null | undefined): string;
+/**
+ * Extract the resource type from a Shopify Global ID.
+ *
+ * @param gid - Shopify Global ID
+ * @returns The resource type (e.g., "Product", "ProductVariant", "Cart")
+ *
+ * @example
+ * ```ts
+ * extractShopifyType("gid://shopify/Product/123"); // "Product"
+ * extractShopifyType("gid://shopify/ProductVariant/456"); // "ProductVariant"
+ * extractShopifyType("123456789"); // null (not a GID)
+ * ```
+ */
+declare function extractShopifyType(gid: string | null | undefined): string | null;
+/**
+ * Check if a string is a Shopify Global ID.
+ *
+ * @param value - String to check
+ * @returns True if it's a GID
+ *
+ * @example
+ * ```ts
+ * isShopifyGid("gid://shopify/Product/123"); // true
+ * isShopifyGid("123456789"); // false
+ * ```
+ */
+declare function isShopifyGid(value: string | null | undefined): boolean;
+/**
+ * Try to detect the shop currency from Shopify's global object.
+ * Only works on Shopify theme stores, not headless.
+ *
+ * @returns Currency code (e.g., "USD") or undefined
+ */
+declare function detectShopifyCurrency(): string | undefined;
+
+/**
+ * Cart attribute utilities for tagging carts with A/B test data
+ *
+ * These functions update Shopify cart attributes with test assignment data,
+ * enabling order attribution for A/B test analysis.
+ */
+
+/**
+ * Get cart attributes payload from current test assignments
+ * Returns an array of key-value pairs ready to be sent to Shopify
+ *
+ * @example
+ * ```ts
+ * const attributes = getCartAttributesPayload();
+ * // Use with your own Storefront client
+ * await storefront.mutate(CART_ATTRIBUTES_UPDATE_MUTATION, {
+ *   variables: { cartId, attributes }
+ * });
+ * ```
+ */
+declare function getCartAttributesPayload(): CartAttributeInput[];
+/**
+ * Update cart attributes with test assignment data
+ *
+ * This function calls the Shopify Storefront API to update cart attributes.
+ *
+ * ## Authentication
+ *
+ * **For Hydrogen stores:** Use your storefront client directly with `getCartAttributesPayload()`
+ *
+ * **For Next.js/Other stores:** Pass the `storefrontAccessToken` option.
+ *
+ * ✅ The Storefront Access Token is **safe to use client-side**.
+ * It's a public token designed by Shopify for browser use.
+ * It can only read products and manage carts - it CANNOT delete products,
+ * access admin functions, or do anything destructive.
+ *
+ * Get your token from: Shopify Admin → Settings → Apps → Develop apps
+ *
+ * @param cartId - The cart ID (GID or token, e.g., "gid://shopify/Cart/abc123" or just "abc123")
+ * @param options - Configuration options including storefrontAccessToken
+ * @returns Promise with success status and optional error message
+ *
+ * @example
+ * ```ts
+ * // Next.js usage - token is safe to use client-side!
+ * const result = await updateCartAttributes(cartId, {
+ *   storefrontAccessToken: process.env.NEXT_PUBLIC_STOREFRONT_TOKEN
+ * });
+ *
+ * if (!result.success) {
+ *   console.error('Failed to update cart attributes:', result.error);
+ * }
+ * ```
+ */
+declare function updateCartAttributes(cartId: string, options?: CartAttributesOptions): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Cleanup/remove cart attributes
+ * Sets all Elevate attributes to empty strings
+ *
+ * @param cartId - The cart ID (GID or token)
+ * @param options - Configuration options including storefrontAccessToken
+ */
+declare function cleanupCartAttributes(cartId: string, options?: CartAttributesOptions): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+
+/**
+ * GraphQL mutations for cart attributes
+ */
+/**
+ * GraphQL mutation for updating cart attributes
+ * Use this in your Storefront API calls
+ */
+declare const CART_ATTRIBUTES_UPDATE_MUTATION = "#graphql\n  mutation cartAttributesUpdate($cartId: ID!, $attributes: [AttributeInput!]!) {\n    cartAttributesUpdate(cartId: $cartId, attributes: $attributes) {\n      cart {\n        id\n        attributes {\n          key\n          value\n        }\n      }\n      userErrors {\n        field\n        message\n      }\n    }\n  }\n";
+
+/**
+ * Manual tracking functions for non-Hydrogen frameworks (Next.js, etc.)
+ *
+ * Initialize once with initAnalytics(), then call tracking functions without params:
+ *
+ * @example
+ * ```tsx
+ * // In your layout/provider (once)
+ * initAnalytics({
+ *   storeId: 'your-store.myshopify.com',
+ *   storefrontAccessToken: 'your-token',
+ * });
+ *
+ * // Then anywhere in your app (no params needed)
+ * trackPageView();
+ * trackAddToCart({ cartId, productId, ... });
+ * ```
+ */
+
+interface AnalyticsConfig {
+    storeId: string;
+    storefrontAccessToken?: string;
+    hasLocalizedPaths?: boolean;
+    workerUrl?: string;
+    ordersWorkerUrl?: string;
+}
+/**
+ * Initialize analytics config once. Call this in your app's entry point or layout.
+ * After init, tracking functions don't need storeId/token params.
+ *
+ * @example
+ * ```tsx
+ * // In _app.tsx or layout.tsx
+ * initAnalytics({
+ *   storeId: 'your-store.myshopify.com',
+ *   storefrontAccessToken: process.env.NEXT_PUBLIC_STOREFRONT_TOKEN,
+ * });
+ * ```
+ */
+declare function initAnalytics(config: AnalyticsConfig): void;
+/**
+ * Track page view event
+ * Call this on route changes or in useEffect
+ *
+ * @example After initAnalytics()
+ * ```ts
+ * await trackPageView(); // No params needed!
+ * ```
+ *
+ * @example Without init (pass params)
+ * ```ts
+ * await trackPageView({ storeId: "mystore.myshopify.com" });
+ * ```
+ */
+declare function trackPageView(params?: Partial<TrackPageViewParams>): Promise<void>;
+/**
+ * Track product view event
+ * Call this on product pages
+ *
+ * @example After initAnalytics()
+ * ```ts
+ * await trackProductView({ productId: "123", productPrice: 99.99 });
+ * ```
+ */
+declare function trackProductView(params: Omit<TrackProductViewParams, "storeId"> & {
+    storeId?: string;
+}): Promise<void>;
+/**
+ * Track add to cart event
+ * Call this when user clicks "Add to Cart"
+ *
+ * Cart attributes are automatically updated for order attribution if
+ * storefrontAccessToken was provided to initAnalytics() or passed here.
+ *
+ * @example After initAnalytics()
+ * ```ts
+ * await trackAddToCart({
+ *   cartId: "gid://shopify/Cart/abc123",
+ *   productId: "123456789",
+ *   variantId: "987654321",
+ *   productPrice: 99.99,
+ *   productQuantity: 1,
+ * });
+ * ```
+ */
+declare function trackAddToCart(params: Omit<TrackAddToCartParams, "storeId" | "storefrontAccessToken"> & {
+    storeId?: string;
+    storefrontAccessToken?: string;
+}): Promise<void>;
+/**
+ * Track remove from cart event
+ * Call this when user removes item from cart
+ */
+declare function trackRemoveFromCart(params: Omit<TrackRemoveFromCartParams, "storeId"> & {
+    storeId?: string;
+}): Promise<void>;
+/**
+ * Track cart view event
+ * Call this when user views cart page
+ */
+declare function trackCartView(params: Omit<TrackCartViewParams, "storeId"> & {
+    storeId?: string;
+}): Promise<void>;
+/**
+ * Track search submitted event
+ * Call this when user submits a search
+ *
+ * @example After initAnalytics()
+ * ```ts
+ * await trackSearchSubmitted({ searchQuery: "running shoes" });
+ * ```
+ *
+ * @example Without init (pass params)
+ * ```ts
+ * await trackSearchSubmitted({
+ *   storeId: "mystore.myshopify.com",
+ *   searchQuery: "running shoes",
+ *   currency: "USD"
+ * });
+ * ```
+ */
+declare function trackSearchSubmitted(params: Omit<TrackSearchSubmittedParams, "storeId"> & {
+    storeId?: string;
+}): Promise<void>;
+/**
+ * Track checkout started event
+ * Call this when user starts checkout
+ *
+ * @example After initAnalytics()
+ * ```ts
+ * await trackCheckoutStarted({
+ *   cartTotalPrice: 109.98,
+ *   cartItems: [...],
+ * });
+ * ```
+ */
+declare function trackCheckoutStarted(params: Omit<TrackCheckoutStartedParams, "storeId"> & {
+    storeId?: string;
+}): Promise<void>;
+/**
+ * Track checkout completed event (order placed)
+ * Call this when order is placed
+ *
+ * NOTE: This sends to a different endpoint (orders worker)
+ *
+ * @example After initAnalytics()
+ * ```ts
+ * await trackCheckoutCompleted({
+ *   orderId: "order_123456",
+ *   cartTotalPrice: 109.98,
+ *   cartItems: [...],
+ * });
+ * ```
+ */
+declare function trackCheckoutCompleted(params: Omit<TrackCheckoutCompletedParams, "storeId"> & {
+    storeId?: string;
+}): Promise<void>;
+/**
+ * Hook for automatic page view tracking on route changes
+ * Use in Next.js app router or any React app
+ *
+ * NOTE: For Next.js App Router, consider using this with `usePathname()`:
+ * ```tsx
+ * const pathname = usePathname();
+ * usePageViewTracking({ pathname, enabled: true });
+ * ```
+ *
+ * @example Basic usage (tracks on mount only)
+ * ```tsx
+ * function Layout({ children }) {
+ *   usePageViewTracking({ enabled: true });
+ *   return <>{children}</>;
+ * }
+ * ```
+ *
+ * @example With Next.js usePathname (tracks on route changes)
+ * ```tsx
+ * import { usePathname } from 'next/navigation';
+ *
+ * function Layout({ children }) {
+ *   const pathname = usePathname();
+ *   usePageViewTracking({ pathname, enabled: true });
+ *   return <>{children}</>;
+ * }
+ * ```
+ */
+declare function usePageViewTracking(params: UsePageViewTrackingParams & {
+    pathname?: string;
+}): void;
+
+interface UseExperimentResult {
+    /** The full variant object (null if not assigned) */
     variant: Variation | null;
+    /** True while loading config */
     isLoading: boolean;
-};
+    /** True if assigned to control group */
+    isControl: boolean;
+    /** True if assigned to variation A (first non-control) */
+    isA: boolean;
+    /** True if assigned to variation B (second non-control) */
+    isB: boolean;
+    /** True if assigned to variation C (third non-control) */
+    isC: boolean;
+    /** True if assigned to variation D (fourth non-control) */
+    isD: boolean;
+}
+/**
+ * Hook to get assigned variant for a test
+ *
+ * @example
+ * ```tsx
+ * const { isControl, isA, isB } = useExperiment('my-test');
+ *
+ * if (isControl) return <Original />;
+ * if (isA) return <VariantA />;
+ * if (isB) return <VariantB />;
+ * ```
+ */
+declare function useExperiment(testId: string): UseExperimentResult;
 
-declare function ElevateProvider({ storeId, children }: ElevateProviderProps): React.JSX.Element;
+interface ElevateProviderSimpleProps {
+    /** Shopify store domain (e.g., "your-store.myshopify.com") */
+    storeId: string;
+    /**
+     * Storefront Access Token - Required for cart attribute tracking (order attribution)
+     *
+     * This is SAFE to use client-side - it's a public token with limited permissions.
+     * Get it from: Shopify Admin → Settings → Apps → Develop apps
+     *
+     * Without this token, A/B tests work but orders won't be attributed to variants.
+     */
+    storefrontAccessToken?: string;
+    /**
+     * Enable flicker prevention - hides content until test assignment is complete
+     * Prevents users from seeing content flash/change when variants load
+     * @default false
+     */
+    preventFlickering?: boolean;
+    /**
+     * Timeout in milliseconds for flicker prevention failsafe
+     * Content will show after this time even if assignment isn't complete
+     * @default 3000
+     */
+    flickerTimeout?: number;
+    children: React.ReactNode;
+}
+/**
+ * ElevateProvider - Provides A/B test configuration to child components
+ *
+ * @example Next.js / Remix
+ * ```tsx
+ * <ElevateProvider
+ *   storeId="your-store.myshopify.com"
+ *   storefrontAccessToken="your-public-token"
+ * >
+ *   <App />
+ * </ElevateProvider>
+ * ```
+ *
+ * @example Hydrogen (with Analytics.Provider)
+ * ```tsx
+ * <Analytics.Provider cart={cart} shop={shop} consent={consent}>
+ *   <ElevateProvider storeId="your-store.myshopify.com" storefrontAccessToken="token">
+ *     <ElevateAnalytics />
+ *     <App />
+ *   </ElevateProvider>
+ * </Analytics.Provider>
+ * ```
+ */
+declare function ElevateProvider({ storeId, storefrontAccessToken, preventFlickering, flickerTimeout, children, }: ElevateProviderSimpleProps): React.JSX.Element;
 
 /**
  * Hook to access Elevate config from context
  */
 declare function useElevateConfig(): ElevateContextValue;
 
-declare const VERSION = "1.1.0";
+declare const VERSION = "1.1.2";
 declare const DEFAULT_CONFIG: {
     enabled: boolean;
     trackingEndpoint: string;
     cacheDuration: number;
 };
 
-export { type BackendConfig, DEFAULT_CONFIG, type ElevateConfig, type ElevateContextValue, ElevateProvider, type ElevateProviderProps, Experiment, type ExperimentStatus, type Test, type TrackingEvent, VERSION, VariantDisplay, type Variation, assignVariant, calculateRevenueLift, generateExperimentId, hashString, useElevateConfig, useExperiment, validateConfig };
+export { type BackendConfig, type BackendTest, type BackendVariation, type BaseTrackingConfig, CART_ATTRIBUTES_UPDATE_MUTATION, COUNTRIES, type CartAttributeInput, type CartAttributesOptions, type CartItemInput, type CartItemPayload, DEFAULT_CONFIG, type ElevateAnalyticsProps, type ElevateConfig, type ElevateContextValue, ElevateProvider, type ElevateProviderProps, type EventPayload, type ExperimentStatus, type GeoLocation, type NoteAttribute, type ParsedViewData, type PreviewState, REGIONS, type Test, type TestAssignment, type TrackAddToCartParams, type TrackCartViewParams, type TrackCheckoutCompletedParams, type TrackCheckoutStartedParams, type TrackPageViewParams, type TrackProductViewParams, type TrackRemoveFromCartParams, type TrackSearchSubmittedParams, type TrackingEvent, type UseExperimentResult, type UsePageViewTrackingParams, VERSION, type Variation, assignAndPersistVariant, assignVariant, buildEabTestsParam, calculateRevenueLift, checkFacebookBrowser, checkFacebookInstagramBrowser, checkInstagramBrowser, checkPinterestBrowser, checkTikTokBrowser, checkVisitorIdParams, cleanCartToken, cleanupCartAttributes, cleanupFlickerPrevention, clearPreviewMode, deleteCookie, detectShopifyCurrency, extractCartToken, extractProductId, extractProductVariantId, extractShopifyId, extractShopifyType, generateExperimentId, getAssignedVariant, getCartAttributesPayload, getCookie, getCountryCode, getDeviceType, getFlickerPreventionScript, getGeoLocation, getJsonCookie, getJsonSessionItem, getPageTypeFromPathname, getPreviewState, getPreviewVariation, getReferrerData, getSessionId, getSessionItem, getTestList, getTrafficSource, getUserAgentNoBrowser, getVisitorId, hasSessionView, hasUniqueView, hashString, hideForFlicker, initAnalytics, initializeSessionId, initializeVisitorId, injectFlickerStyles, isCountryExcluded, isCountryIncluded, isFlickerPreventionActive, isInPreviewMode, isPreviewTest, isShopifyGid, matchesGeoTargeting, parseAddViewData, revealAfterFlicker, roundToTwo, sanitizeString, saveTestList, setCookie, setCountryCode, setGeoLocation, setReferrerData, setSessionItem, setupFlickerPrevention, shouldShowTest, trackAddToCart, trackCartView, trackCheckoutCompleted, trackCheckoutStarted, trackPageView, trackProductView, trackRemoveFromCart, trackSearchSubmitted, trackSessionView, trackUniqueView, trackViews, updateCartAttributes, updateUrlWithTestParams, useElevateConfig, useExperiment, usePageViewTracking, uuidv4, validateConfig };