@kasuvia/sdk 0.0.2 → 0.0.5

package/dist/hooks/index.mjs

@@ -0,0 +1,2962 @@
+// src/hooks/use-cart.ts
+import React2, { useContext as useContext2, useState } from "react";
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+
+// src/services/cart.service.ts
+function parseItems(items) {
+  return items.map((item) => ({
+    ...item,
+    variant_attributes: item.variant_attributes && typeof item.variant_attributes === "string" ? JSON.parse(item.variant_attributes) : item.variant_attributes
+  }));
+}
+async function getGuestCart(config, guestSessionId) {
+  if (!guestSessionId) return [];
+  try {
+    const response = await fetch(`${config.backendUrls.store}/cart/`, {
+      headers: {
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId,
+        "X-Guest-Session": guestSessionId
+      }
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return parseItems(data.items || []);
+  } catch {
+    return [];
+  }
+}
+async function getCart(config, accessToken) {
+  if (!accessToken) {
+    return { id: "", items: [], subtotal: 0, total: 0, product_type: "physical" };
+  }
+  const response = await fetch(`${config.backendUrls.store}/cart/`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to fetch cart");
+  const data = await response.json();
+  const parsedItems = parseItems(data.items || []);
+  return { ...data, items: parsedItems };
+}
+async function addToCart(config, accessToken, item) {
+  const response = await fetch(`${config.backendUrls.store}/cart/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(item)
+  });
+  if (!response.ok) throw new Error("Failed to add to cart");
+  const data = await response.json();
+  const parsedItems = parseItems(data.items || []);
+  return { ...data, items: parsedItems };
+}
+async function updateCartItem(config, accessToken, itemId, quantity) {
+  const response = await fetch(`${config.backendUrls.store}/cart/${itemId}`, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({ quantity })
+  });
+  if (!response.ok) throw new Error("Failed to update cart item");
+  const data = await response.json();
+  const parsedItems = parseItems(data.items || []);
+  return { ...data, items: parsedItems };
+}
+async function removeFromCart(config, accessToken, itemId) {
+  await fetch(`${config.backendUrls.store}/cart/${itemId}`, {
+    method: "DELETE",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  return getCart(config, accessToken);
+}
+async function clearCart(config, accessToken) {
+  await fetch(`${config.backendUrls.store}/cart/clear`, {
+    method: "DELETE",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+}
+async function mergeGuestCart(config, accessToken, guestSessionId) {
+  const guestItems = guestSessionId ? await getGuestCart(config, guestSessionId) : [];
+  if (guestItems.length === 0) {
+    return getCart(config, accessToken);
+  }
+  const payloadItems = guestItems.map((item) => ({
+    product_id: item.product_id,
+    product_slug: item.product_slug,
+    product_name: item.product_name,
+    image: item.image,
+    variant_id: item.variant_id,
+    variant_attributes: typeof item.variant_attributes === "string" ? item.variant_attributes : JSON.stringify(item.variant_attributes ?? {}),
+    unit_price: item.unit_price,
+    quantity: item.quantity,
+    custom_measurements: typeof item.custom_measurements === "string" ? item.custom_measurements : JSON.stringify(item.custom_measurements ?? {}),
+    is_bespoke: item.is_bespoke
+  }));
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${accessToken}`,
+    "X-Storefront-Key": config.storefrontApiKey,
+    "X-Business-ID": config.businessId
+  };
+  if (guestSessionId) {
+    headers["X-Guest-Session"] = guestSessionId;
+  }
+  const response = await fetch(`${config.backendUrls.store}/cart/merge`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ items: payloadItems })
+  });
+  if (!response.ok) throw new Error("Failed to merge guest cart");
+  const data = await response.json();
+  return { ...data, items: parseItems(data.items || []) };
+}
+async function mergeGuestCartIfPresent(config, accessToken, guestSessionId) {
+  try {
+    const guestItems = await getGuestCart(config, guestSessionId);
+    if (guestItems.length === 0) return;
+    await mergeGuestCart(config, accessToken, guestSessionId);
+  } catch (error) {
+    console.warn("[Cart] Failed to merge guest cart:", error);
+  }
+}
+
+// src/context/sdk-context.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var SdkContext = createContext(null);
+function SdkProvider({ config, accessToken, children }) {
+  return /* @__PURE__ */ jsx(SdkContext.Provider, { value: { config, accessToken }, children });
+}
+function useSdkContext() {
+  return useContext(SdkContext);
+}
+function resolveHookArgs(explicitConfig, explicitToken, ctx) {
+  const config = explicitConfig ?? ctx?.config;
+  if (!config) {
+    throw new Error(
+      "[kasuvia-sdk] No SdkConfig found. Either pass config explicitly or wrap your app with <SdkProvider config={...}>."
+    );
+  }
+  const accessToken = explicitToken !== void 0 ? explicitToken : ctx?.accessToken ?? null;
+  return { config, accessToken };
+}
+
+// src/hooks/use-cart.ts
+var CartCtx = React2.createContext ? React2.createContext(null) : null;
+function CartProvider({ children }) {
+  const [isOpen, setIsOpen] = useState(false);
+  if (!CartCtx) return children;
+  return React2.createElement(CartCtx.Provider, { value: { isOpen, setOpen: setIsOpen } }, children);
+}
+function useCart(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const resolved = resolveHookArgs(config, accessToken, ctx);
+    const resolvedConfig = resolved.config;
+    const resolvedToken = resolved.accessToken;
+    const queryClient = useQueryClient();
+    const context = CartCtx ? useContext2(CartCtx) : null;
+    const isOpen = context ? context.isOpen : false;
+    const setOpen = context ? context.setOpen : () => {
+    };
+    const [productTypeMismatch, setProductTypeMismatch] = useState(null);
+    const cartQuery = useQuery({
+      queryKey: ["cart"],
+      queryFn: async () => {
+        if (resolvedToken) {
+          return getCart(resolvedConfig, resolvedToken);
+        }
+        if (typeof window !== "undefined") {
+          const res = await fetch("/api/cart", { credentials: "include" });
+          if (!res.ok) throw new Error("Failed to fetch cart");
+          return res.json();
+        }
+        return void 0;
+      },
+      enabled: true
+    });
+    const addToCartMutation = useMutation({
+      mutationFn: async (item) => {
+        if (resolvedToken) {
+          return addToCart(resolvedConfig, resolvedToken, item);
+        }
+        if (typeof window !== "undefined") {
+          const res = await fetch("/api/cart", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            credentials: "include",
+            body: JSON.stringify(item)
+          });
+          if (!res.ok) {
+            const data = await res.json().catch(() => ({}));
+            throw { status: res.status, data };
+          }
+          return res.json();
+        }
+        throw new Error("No access token and not in browser context");
+      },
+      onSuccess: () => {
+        setProductTypeMismatch(null);
+        queryClient.invalidateQueries({ queryKey: ["cart"] });
+      },
+      onError: (error) => {
+        const err = error;
+        if (err.status === 409 && err.data?.detail?.code === "CART_PRODUCT_TYPE_MISMATCH") {
+          const errorDetail = err.data.detail;
+          setProductTypeMismatch({
+            message: errorDetail.message ?? "Your cart contains incompatible items.",
+            existing_type: errorDetail.existing_type ?? "physical",
+            new_type: errorDetail.new_type ?? "physical"
+          });
+        }
+      }
+    });
+    const updateCartItemMutation = useMutation({
+      mutationFn: async ({ itemId, quantity }) => {
+        if (resolvedToken) {
+          return updateCartItem(resolvedConfig, resolvedToken, itemId, quantity);
+        }
+        if (typeof window !== "undefined") {
+          const res = await fetch(`/api/cart/${itemId}`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            credentials: "include",
+            body: JSON.stringify({ quantity })
+          });
+          if (!res.ok) throw new Error("Failed to update cart item");
+          return res.json();
+        }
+        throw new Error("No access token");
+      },
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["cart"] });
+      }
+    });
+    const removeFromCartMutation = useMutation({
+      mutationFn: async (itemId) => {
+        if (resolvedToken) {
+          return removeFromCart(resolvedConfig, resolvedToken, itemId);
+        }
+        if (typeof window !== "undefined") {
+          const res = await fetch(`/api/cart/${itemId}`, {
+            method: "DELETE",
+            credentials: "include"
+          });
+          if (!res.ok) throw new Error("Failed to remove cart item");
+          return res.json();
+        }
+        throw new Error("No access token");
+      },
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["cart"] });
+      }
+    });
+    const clearCartMutation = useMutation({
+      mutationFn: async () => {
+        if (resolvedToken) {
+          return clearCart(resolvedConfig, resolvedToken);
+        }
+        if (typeof window !== "undefined") {
+          const res = await fetch("/api/cart/clear", {
+            method: "DELETE",
+            credentials: "include"
+          });
+          if (!res.ok) throw new Error("Failed to clear cart");
+          return res.json();
+        }
+        throw new Error("No access token");
+      },
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["cart"] });
+      }
+    });
+    const mergeGuestCartMutation = useMutation({
+      mutationFn: (guestSessionId) => resolvedToken ? mergeGuestCartIfPresent(resolvedConfig, resolvedToken, guestSessionId) : Promise.resolve(),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["cart"] });
+      }
+    });
+    const addItem = (product, variantId, quantity = 1, customMeasurements) => {
+      const variant = variantId ? product.variants.find((v) => v.id === variantId) : void 0;
+      return addToCartMutation.mutate({
+        product_id: product.id,
+        product_slug: product.slug,
+        product_name: product.name,
+        image: product.images[0] || void 0,
+        variant_id: variantId,
+        variant_attributes: variant?.attributes ? JSON.stringify(variant.attributes) : void 0,
+        unit_price: variant?.price ?? product.base_price,
+        quantity,
+        custom_measurements: customMeasurements ? JSON.stringify(customMeasurements) : void 0,
+        is_bespoke: product.is_bespoke
+      });
+    };
+    const items = cartQuery.data?.items || [];
+    const subtotal = cartQuery.data?.subtotal || 0;
+    const count = items.reduce((total, item) => total + item.quantity, 0);
+    const updateQty = (itemId, quantity) => {
+      updateCartItemMutation.mutate({ itemId, quantity });
+    };
+    const removeItem = (itemId) => {
+      removeFromCartMutation.mutate(itemId);
+    };
+    const handleClearCartAndAdd = () => {
+      clearCartMutation.mutate();
+      setProductTypeMismatch(null);
+    };
+    const handleKeepCurrentCart = () => {
+      setProductTypeMismatch(null);
+    };
+    return {
+      cart: cartQuery.data,
+      items,
+      count,
+      isOpen,
+      setOpen,
+      isLoading: cartQuery.isLoading,
+      error: cartQuery.error,
+      addToCart: addToCartMutation.mutate,
+      updateCartItem: updateCartItemMutation.mutate,
+      removeFromCart: removeFromCartMutation.mutate,
+      clearCart: clearCartMutation.mutate,
+      clear: clearCartMutation.mutate,
+      // Alias for storefront compatibility
+      mergeGuestCart: mergeGuestCartMutation.mutate,
+      addItem,
+      updateQty,
+      removeItem,
+      subtotal,
+      productTypeMismatch,
+      handleClearCartAndAdd,
+      handleKeepCurrentCart
+    };
+  } catch (error) {
+    console.warn("[useCart] Called outside QueryClientProvider, returning empty cart");
+    const context = CartCtx ? useContext2(CartCtx) : null;
+    const isOpen = context ? context.isOpen : false;
+    const setOpen = context ? context.setOpen : () => {
+    };
+    return {
+      cart: void 0,
+      items: [],
+      count: 0,
+      isOpen,
+      setOpen,
+      isLoading: false,
+      error: null,
+      addToCart: () => {
+      },
+      updateCartItem: () => {
+      },
+      removeFromCart: () => {
+      },
+      clearCart: () => {
+      },
+      clear: () => {
+      },
+      mergeGuestCart: () => {
+      },
+      addItem: () => {
+      },
+      updateQty: () => {
+      },
+      removeItem: () => {
+      },
+      subtotal: 0,
+      productTypeMismatch: null,
+      handleClearCartAndAdd: () => {
+      },
+      handleKeepCurrentCart: () => {
+      }
+    };
+  }
+}
+
+// src/hooks/use-orders.ts
+import { useQuery as useQuery2, useMutation as useMutation2, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+
+// src/services/order.service.ts
+function deriveCustomerName(raw) {
+  if (raw.customer_name) return raw.customer_name;
+  if (raw.guest_name) return raw.guest_name;
+  const addr = typeof raw.shipping_address === "object" && raw.shipping_address !== null ? raw.shipping_address : null;
+  if (addr) {
+    const full = `${addr.first_name ?? ""} ${addr.last_name ?? ""}`.trim();
+    if (full) return full;
+  }
+  const email = raw.guest_email ?? raw.customer_email ?? "";
+  if (email) return email.split("@")[0];
+  return "";
+}
+function normaliseStorefrontOrder(raw) {
+  const items = (raw.items ?? []).map((item) => ({
+    id: item.id,
+    productName: item.product_name ?? item.productName ?? "",
+    image: item.image ?? "",
+    quantity: item.quantity ?? 1,
+    price: item.unit_price ?? item.price ?? 0
+  }));
+  const addr = typeof raw.shipping_address === "object" && raw.shipping_address !== null ? raw.shipping_address : null;
+  return {
+    id: raw.id,
+    display_id: raw.display_id,
+    items,
+    total: raw.total_amount ?? raw.total ?? 0,
+    status: raw.status,
+    customerEmail: raw.guest_email ?? raw.customer_email ?? "",
+    customerName: deriveCustomerName(raw),
+    createdAt: raw.created_at ? new Date(raw.created_at).getTime() : Date.now(),
+    updatedAt: raw.updated_at ? new Date(raw.updated_at).getTime() : Date.now(),
+    deliveryMethod: raw.delivery_method,
+    trackingNumber: raw.tracking_number,
+    deliveryAddress: typeof raw.shipping_address === "string" ? raw.shipping_address : addr ? `${addr.street}, ${addr.city}, ${addr.state}, ${addr.country}` : void 0,
+    shippingAddress: addr ? {
+      first_name: addr.first_name ?? "",
+      last_name: addr.last_name ?? "",
+      phone: addr.phone ?? "",
+      street: addr.street ?? "",
+      city: addr.city ?? "",
+      state: addr.state ?? "",
+      lga: addr.lga ?? "",
+      country: addr.country ?? "",
+      postal: addr.postal ?? ""
+    } : void 0,
+    cancellationReason: raw.cancellation_reason,
+    hasBespoke: raw.product_type === "bespoke",
+    bespokeStage: raw.bespoke_stage,
+    bespokeBrief: raw.bespoke_brief,
+    deliveryStatus: raw.delivery_status,
+    carrierName: raw.carrier_name,
+    terminalShipmentId: raw.terminal_shipment_id,
+    guestToken: raw.guest_token,
+    guestEmail: raw.guest_email,
+    guestPhone: raw.guest_phone,
+    guestName: raw.guest_name
+  };
+}
+async function createOrder(config, accessToken, payload) {
+  const response = await fetch(`${config.backendUrls.store}/orders/storefront`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) throw new Error("Failed to create order");
+  const data = await response.json();
+  return normaliseStorefrontOrder(data);
+}
+async function findOrder(config, params) {
+  const queryParams = new URLSearchParams();
+  if (params.email) queryParams.set("email", params.email);
+  if (params.order_id) queryParams.set("order_id", params.order_id);
+  if (params.guest_token) queryParams.set("guest_token", params.guest_token);
+  const response = await fetch(`${config.backendUrls.store}/orders/find/?${queryParams.toString()}`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to find order");
+  const data = await response.json();
+  return normaliseStorefrontOrder(data);
+}
+async function getOrders(config, accessToken, params) {
+  const queryParams = new URLSearchParams();
+  if (params?.email) queryParams.set("email", params.email);
+  if (params?.page) queryParams.set("page", params.page.toString());
+  if (params?.page_size) queryParams.set("page_size", params.page_size.toString());
+  const response = await fetch(`${config.backendUrls.store}/orders/?${queryParams.toString()}`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get orders");
+  const data = await response.json();
+  const items = Array.isArray(data) ? data : data.items ?? [];
+  return items.map(normaliseStorefrontOrder);
+}
+async function cancelOrder(config, accessToken, orderId, reason) {
+  const response = await fetch(`${config.backendUrls.store}/orders/${orderId}/cancel/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({ reason })
+  });
+  if (!response.ok) throw new Error("Failed to cancel order");
+  const data = await response.json();
+  return normaliseStorefrontOrder(data);
+}
+async function trackOrder(config, orderId, token) {
+  const queryParams = token ? `?token=${token}` : "";
+  const response = await fetch(`${config.backendUrls.store}/orders/track/${orderId}${queryParams}`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to track order");
+  const data = await response.json();
+  return normaliseStorefrontOrder(data);
+}
+
+// src/utils/cache.ts
+var CACHE_TIERS = {
+  none: { staleTime: 0, gcTime: 0 },
+  infinity: { staleTime: Infinity, gcTime: 0 },
+  low: { staleTime: 1e3 * 30, gcTime: 1e3 * 60 },
+  // 30s / 1m
+  medium: { staleTime: 1e3 * 60 * 5, gcTime: 1e3 * 60 * 10 },
+  // 5m / 10m
+  high: { staleTime: 1e3 * 60 * 30, gcTime: 1e3 * 60 * 60 }
+  // 30m / 1h
+};
+var isDevelopment = true;
+var getCacheTier = (tier) => {
+  if (isDevelopment) return CACHE_TIERS.none;
+  return CACHE_TIERS[tier];
+};
+
+// src/utils/logger.ts
+var isDevelopment2 = true;
+var logger = {
+  log: (...args) => {
+    if (isDevelopment2) {
+      console.log(...args);
+    }
+  },
+  warn: (...args) => {
+    if (isDevelopment2) {
+      console.warn(...args);
+    }
+  },
+  /**
+   * Logs a warning to the console in development only.
+   * Alias for warn() for Python logging compatibility.
+   * In production, this is a no-op.
+   */
+  warning: (...args) => {
+    if (isDevelopment2) {
+      console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    if (isDevelopment2) {
+      console.error(...args);
+    }
+  },
+  info: (...args) => {
+    if (isDevelopment2) {
+      console.info(...args);
+    }
+  },
+  createScope: (scope) => ({
+    log: (...args) => {
+      if (isDevelopment2) {
+        console.log(`[${scope}]`, ...args);
+      }
+    },
+    warn: (...args) => {
+      if (isDevelopment2) {
+        console.warn(`[${scope}]`, ...args);
+      }
+    },
+    warning: (...args) => {
+      if (isDevelopment2) {
+        console.warn(`[${scope}]`, ...args);
+      }
+    },
+    error: (...args) => {
+      if (isDevelopment2) {
+        console.error(`[${scope}]`, ...args);
+      }
+    },
+    info: (...args) => {
+      if (isDevelopment2) {
+        console.info(`[${scope}]`, ...args);
+      }
+    }
+  })
+};
+
+// src/hooks/use-orders.ts
+function useOrders(arg1, arg2, arg3) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null && "businessId" in arg1;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const explicitToken = isArg1Config ? arg2 : void 0;
+  const params = isArg1Config ? arg3 : arg1;
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx);
+    return useQuery2({
+      queryKey: ["orders", params],
+      queryFn: () => token ? getOrders(cfg, token, params || {}) : Promise.resolve(void 0),
+      enabled: !!token
+    });
+  } catch (error) {
+    logger.warn("[useOrders] Called outside QueryClientProvider, returning empty list");
+    return { data: void 0, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: void 0 }) };
+  }
+}
+function useOrdersList(arg1, arg2, arg3) {
+  return useOrders(arg1, arg2, arg3);
+}
+function useFindOrder(arg1, arg2) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null && "businessId" in arg1;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const params = isArg1Config ? arg2 : typeof arg1 === "string" ? { order_id: arg1, email: "" } : arg1;
+  try {
+    const { config: cfg } = resolveHookArgs(explicitConfig, void 0, ctx);
+    return useQuery2({
+      queryKey: ["order", params],
+      queryFn: () => params ? findOrder(cfg, params) : Promise.resolve(void 0),
+      enabled: !!params?.order_id
+    });
+  } catch (error) {
+    logger.warn("[useFindOrder] Called outside QueryClientProvider, returning undefined");
+    return { data: void 0, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: void 0 }) };
+  }
+}
+function useOrder(arg1, arg2) {
+  return useFindOrder(arg1, arg2);
+}
+function useOrderTracking(arg1, arg2, arg3) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null && "businessId" in arg1;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const orderId = isArg1Config ? arg2 : typeof arg1 === "string" ? arg1 : void 0;
+  const guestToken = isArg1Config ? arg3 : typeof arg2 === "string" ? arg2 : void 0;
+  try {
+    const { config: cfg } = resolveHookArgs(explicitConfig, void 0, ctx);
+    return useQuery2({
+      queryKey: ["order-tracking", orderId, guestToken],
+      queryFn: () => trackOrder(cfg, orderId, guestToken),
+      enabled: !!orderId,
+      refetchInterval: 3e4
+    });
+  } catch (error) {
+    logger.warn("[useOrderTracking] Called outside QueryClientProvider, returning undefined");
+    return { data: void 0, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: void 0 }) };
+  }
+}
+function useCreateOrder(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient2();
+    return useMutation2({
+      mutationFn: (payload) => createOrder(cfg, token || "", payload),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["orders"] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useCreateOrder] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+function useCancelOrder(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient2();
+    return useMutation2({
+      mutationFn: ({ orderId, reason = "" }) => token ? cancelOrder(cfg, token, orderId, reason) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["orders"] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useCancelOrder] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+
+// src/hooks/use-auth.ts
+import { useQuery as useQuery3, useMutation as useMutation3, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+
+// src/services/auth.service.ts
+async function loginCustomer(config, payload) {
+  const response = await fetch(`${config.backendUrls.auth}/auth/login/customer/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({
+      ...payload,
+      tenant_id: config.businessId
+    })
+  });
+  if (!response.ok) {
+    throw new Error("Login failed");
+  }
+  const data = await response.json();
+  return data;
+}
+async function registerCustomer(config, payload) {
+  const response = await fetch(`${config.backendUrls.auth}/auth/register/customer/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({
+      ...payload,
+      tenant_id: config.businessId
+    })
+  });
+  if (!response.ok) {
+    throw new Error("Registration failed");
+  }
+  const data = await response.json();
+  return data;
+}
+async function logout(config, refresh) {
+  const payload = refresh ? { refresh } : {};
+  try {
+    await fetch(`${config.backendUrls.auth}/auth/logout/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+  } catch {
+  }
+}
+function resolveProvider(data) {
+  if (data.is_google_auth_enabled) return "google";
+  if (data.is_facebook_auth_enabled) return "facebook";
+  return "email";
+}
+function resolveAvatar(profilePicture) {
+  if (!profilePicture) return null;
+  if (typeof profilePicture === "string") return profilePicture;
+  if (typeof profilePicture === "object" && profilePicture !== null && "url" in profilePicture) {
+    const url = profilePicture.url;
+    return typeof url === "string" ? url : null;
+  }
+  return null;
+}
+function mapAuthUserToCustomer(data, provider) {
+  const firstname = data.profile?.firstname?.trim() || void 0;
+  const lastname = data.profile?.lastname?.trim() || void 0;
+  const phone = data.profile?.phone?.trim() || void 0;
+  return {
+    id: String(data.id),
+    email: data.email,
+    firstname,
+    lastname,
+    phone,
+    full_name: buildFullName2(firstname, lastname),
+    avatar: resolveAvatar(data.profile?.profile_picture),
+    provider: provider ?? resolveProvider(data)
+  };
+}
+async function getAuthUser(config, accessToken) {
+  if (!config || !accessToken) {
+    const response2 = await fetch("/api/auth/me", { credentials: "include" });
+    if (!response2.ok) throw new Error("Failed to fetch auth user");
+    const data2 = await response2.json();
+    return data2.user;
+  }
+  const response = await fetch(`${config.backendUrls.auth}/auth/profile/`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error("Failed to fetch auth user");
+  }
+  const data = await response.json();
+  return data;
+}
+async function updateProfile(configOrPayload, accessTokenOrPayload, payloadParam) {
+  const isArg1Config = typeof configOrPayload === "object" && configOrPayload !== null && "businessId" in configOrPayload;
+  if (!isArg1Config) {
+    const payload2 = configOrPayload;
+    const response2 = await fetch("/api/auth/profile", {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(payload2)
+    });
+    if (!response2.ok) throw new Error("Failed to update profile");
+    return response2.json();
+  }
+  const config = configOrPayload;
+  const accessToken = accessTokenOrPayload;
+  const payload = payloadParam;
+  const response = await fetch(`${config.backendUrls.auth}/auth/profile/`, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to update profile");
+  }
+  const data = await response.json();
+  return mapAuthUserToCustomer(data);
+}
+function buildFullName2(firstname, lastname) {
+  if (firstname && lastname) return `${firstname} ${lastname}`;
+  return firstname || lastname || "";
+}
+
+// src/hooks/use-auth.ts
+function useAuthUser(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken ?? null, ctx);
+    return useQuery3({
+      queryKey: ["auth-user"],
+      queryFn: () => getAuthUser(cfg, token ?? ""),
+      enabled: !!token
+    });
+  } catch (error) {
+    logger.warn("[useAuthUser] Called outside QueryClientProvider, returning empty user");
+    return { data: void 0, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: void 0 }) };
+  }
+}
+function useLogin(config) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg } = resolveHookArgs(config, void 0, ctx);
+    const queryClient = useQueryClient3();
+    return useMutation3({
+      mutationFn: (payload) => loginCustomer(cfg, payload),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["auth-user"] });
+        queryClient.invalidateQueries({ queryKey: ["cart"] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useLogin] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+function useRegister(config) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg } = resolveHookArgs(config, void 0, ctx);
+    const queryClient = useQueryClient3();
+    return useMutation3({
+      mutationFn: (payload) => registerCustomer(cfg, payload),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["auth-user"] });
+        queryClient.invalidateQueries({ queryKey: ["cart"] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useRegister] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+function useUpdateProfile(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient3();
+    return useMutation3({
+      mutationFn: (payload) => token ? updateProfile(cfg, token, payload) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["auth-user"] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useUpdateProfile] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+function useLogout(config, refreshToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg } = resolveHookArgs(config, void 0, ctx);
+    const queryClient = useQueryClient3();
+    return useMutation3({
+      mutationFn: () => logout(cfg, refreshToken),
+      onSuccess: () => {
+        queryClient.clear();
+      }
+    });
+  } catch (error) {
+    logger.warn("[useLogout] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+
+// src/hooks/use-countries.ts
+import { useQuery as useQuery4 } from "@tanstack/react-query";
+async function getCountries(config) {
+  const response = await fetch(`${config.backendUrls.auth}/auth/countries/`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to fetch countries");
+  return response.json();
+}
+function useCountries(config) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg } = resolveHookArgs(config, void 0, ctx);
+    return useQuery4({
+      queryKey: ["countries"],
+      queryFn: () => getCountries(cfg),
+      retry: 1,
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: false,
+      staleTime: 24 * 60 * 60 * 1e3
+    });
+  } catch (error) {
+    logger.warn("[useCountries] Called outside QueryClientProvider, returning empty list");
+    return {
+      data: [],
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: [] })
+    };
+  }
+}
+
+// src/hooks/use-states.ts
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+async function getStates(config, countryIso) {
+  if (!countryIso) return [];
+  const response = await fetch(`${config.backendUrls.auth}/auth/countries/?iso=${countryIso}`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to fetch states");
+  return response.json();
+}
+function useStates(countryIso, config) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg } = resolveHookArgs(config, void 0, ctx);
+    return useQuery5({
+      queryKey: ["states", countryIso],
+      queryFn: () => getStates(cfg, countryIso),
+      enabled: !!countryIso,
+      retry: 1,
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: false,
+      staleTime: 24 * 60 * 60 * 1e3
+    });
+  } catch (error) {
+    logger.warn("[useStates] Called outside QueryClientProvider, returning empty list");
+    return {
+      data: [],
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: [] })
+    };
+  }
+}
+
+// src/hooks/use-languages.ts
+import { useQuery as useQuery6 } from "@tanstack/react-query";
+
+// src/services/config.service.ts
+async function getSupportedLanguages(config) {
+  const response = await fetch(`${config.backendUrls.payment}/config/supported-languages`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get supported languages");
+  return response.json();
+}
+async function getSupportedCurrencies(config) {
+  const response = await fetch(`${config.backendUrls.payment}/config/supported-currencies`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get supported currencies");
+  return response.json();
+}
+
+// src/hooks/use-languages.ts
+async function getSupportedLanguagesList(config) {
+  const data = await getSupportedLanguages(config);
+  return (data.languages || []).map((language) => ({
+    code: language.code,
+    appCode: language.code,
+    label: language.label,
+    native: language.label,
+    flag: language.flag
+  }));
+}
+function useSupportedLanguages(config) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg } = resolveHookArgs(config, void 0, ctx);
+    return useQuery6({
+      queryKey: ["supported-languages"],
+      queryFn: () => getSupportedLanguagesList(cfg),
+      retry: 1,
+      ...getCacheTier("high")
+    });
+  } catch {
+    return {
+      data: [],
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      isPending: false,
+      isError: false,
+      isSuccess: true,
+      status: "success",
+      fetchStatus: "idle",
+      refetch: async () => ({
+        data: [],
+        isLoading: false,
+        error: null,
+        isFetching: false,
+        isPending: false,
+        isError: false,
+        isSuccess: true,
+        status: "success",
+        fetchStatus: "idle"
+      })
+    };
+  }
+}
+
+// src/hooks/use-currencies.ts
+import { useQuery as useQuery7 } from "@tanstack/react-query";
+async function getSupportedCurrenciesList(config) {
+  const data = await getSupportedCurrencies(config);
+  return data.currencies || [];
+}
+function useCurrencies(config) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg } = resolveHookArgs(config, void 0, ctx);
+    return useQuery7({
+      queryKey: ["supported-currencies"],
+      queryFn: () => getSupportedCurrenciesList(cfg),
+      retry: 1,
+      ...getCacheTier("high")
+    });
+  } catch (error) {
+    logger.warn("[useCurrencies] Called outside QueryClientProvider, returning empty list");
+    return {
+      data: [],
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: [] })
+    };
+  }
+}
+
+// src/hooks/use-bespoke-availability.ts
+import { useQuery as useQuery8 } from "@tanstack/react-query";
+
+// src/services/bespoke.service.ts
+async function checkAvailability(config, product_id) {
+  const response = await fetch(`${config.backendUrls.store}/bespoke/availability/${product_id}`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to check bespoke availability");
+  return response.json();
+}
+
+// src/hooks/use-bespoke-availability.ts
+function useBespokeAvailability(product_id, config) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg } = resolveHookArgs(config, void 0, ctx);
+    return useQuery8({
+      queryKey: ["bespoke-availability", product_id],
+      queryFn: () => checkAvailability(cfg, product_id),
+      enabled: !!product_id,
+      retry: false
+    });
+  } catch (error) {
+    logger.warn("[useBespokeAvailability] Called outside QueryClientProvider, returning undefined");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+
+// src/hooks/use-collections.ts
+import { useQuery as useQuery9 } from "@tanstack/react-query";
+var collectionKeys = {
+  all: ["core", "collections"],
+  list: (params) => ["core", "collections", "list", params ?? {}],
+  slug: (slug) => ["core", "collections", "slug", slug]
+};
+function useStorefrontCollections(params) {
+  try {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.set("page", params.page.toString());
+    if (params?.pageSize) queryParams.set("pageSize", params.pageSize.toString());
+    return useQuery9({
+      queryKey: collectionKeys.list(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/collections?${queryParams.toString()}`);
+        if (!response.ok) throw new Error("Failed to fetch collections");
+        return response.json();
+      },
+      // medium — collections change infrequently
+      ...getCacheTier("medium")
+    });
+  } catch (error) {
+    logger.warn("[useStorefrontCollections] Called outside QueryClientProvider, returning empty list");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+function useStorefrontCollection(slug) {
+  try {
+    return useQuery9({
+      queryKey: collectionKeys.slug(slug),
+      queryFn: async () => {
+        const response = await fetch(`/api/collections/${slug}`);
+        if (!response.ok) throw new Error("Failed to fetch collection");
+        return response.json();
+      },
+      // medium — collection details change infrequently
+      ...getCacheTier("medium"),
+      enabled: !!slug
+    });
+  } catch (error) {
+    logger.warn("[useStorefrontCollection] Called outside QueryClientProvider, returning undefined");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+
+// src/hooks/use-products.ts
+import { useQuery as useQuery10 } from "@tanstack/react-query";
+var productKeys = {
+  all: ["products"],
+  list: (params) => [...productKeys.all, "list", params],
+  detail: (slug) => [...productKeys.all, "detail", slug],
+  recommended: (params) => [...productKeys.all, "recommended", params],
+  latest: (params) => [...productKeys.all, "latest", params],
+  popular: (params) => [...productKeys.all, "popular", params],
+  featured: (params) => [...productKeys.all, "featured", params],
+  new: (params) => [...productKeys.all, "new", params],
+  onSale: (params) => [...productKeys.all, "onSale", params],
+  lowStock: (params) => [...productKeys.all, "lowStock", params]
+};
+function useLatestProducts(params) {
+  try {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.set("page", params.page.toString());
+    if (params?.pageSize) queryParams.set("pageSize", params.pageSize.toString());
+    return useQuery10({
+      queryKey: productKeys.latest(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/latest?${queryParams.toString()}`);
+        if (!response.ok) throw new Error("Failed to fetch latest products");
+        return response.json();
+      },
+      // medium — latest products change infrequently
+      ...getCacheTier("medium")
+    });
+  } catch (error) {
+    logger.warn("[useLatestProducts] Called outside QueryClientProvider, returning empty list");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+function usePopularProducts(params) {
+  try {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.set("page", params.page.toString());
+    if (params?.pageSize) queryParams.set("pageSize", params.pageSize.toString());
+    return useQuery10({
+      queryKey: productKeys.popular(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/popular?${queryParams.toString()}`);
+        if (!response.ok) throw new Error("Failed to fetch popular products");
+        return response.json();
+      },
+      // medium — popular products change infrequently
+      ...getCacheTier("medium")
+    });
+  } catch (error) {
+    logger.warn("[usePopularProducts] Called outside QueryClientProvider, returning empty list");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+function useFeaturedProducts(params) {
+  try {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.set("page", params.page.toString());
+    if (params?.pageSize) queryParams.set("pageSize", params.pageSize.toString());
+    return useQuery10({
+      queryKey: productKeys.featured(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/featured?${queryParams.toString()}`);
+        if (!response.ok) throw new Error("Failed to fetch featured products");
+        return response.json();
+      },
+      // medium — featured products change infrequently
+      ...getCacheTier("medium")
+    });
+  } catch (error) {
+    logger.warn("[useFeaturedProducts] Called outside QueryClientProvider, returning empty list");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+function useNewProducts(params) {
+  try {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.set("page", params.page.toString());
+    if (params?.pageSize) queryParams.set("pageSize", params.pageSize.toString());
+    return useQuery10({
+      queryKey: productKeys.new(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/new?${queryParams.toString()}`);
+        if (!response.ok) throw new Error("Failed to fetch new products");
+        return response.json();
+      },
+      // medium — new products change infrequently
+      ...getCacheTier("medium")
+    });
+  } catch (error) {
+    logger.warn("[useNewProducts] Called outside QueryClientProvider, returning empty list");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+function useOnSaleProducts(params) {
+  try {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.set("page", params.page.toString());
+    if (params?.pageSize) queryParams.set("pageSize", params.pageSize.toString());
+    return useQuery10({
+      queryKey: productKeys.onSale(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/on-sale?${queryParams.toString()}`);
+        if (!response.ok) throw new Error("Failed to fetch on-sale products");
+        return response.json();
+      },
+      // medium — sale products change infrequently
+      ...getCacheTier("medium")
+    });
+  } catch (error) {
+    logger.warn("[useOnSaleProducts] Called outside QueryClientProvider, returning empty list");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+function useLowStockProducts(params) {
+  try {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.set("page", params.page.toString());
+    if (params?.pageSize) queryParams.set("pageSize", params.pageSize.toString());
+    return useQuery10({
+      queryKey: productKeys.lowStock(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/low-stock?${queryParams.toString()}`);
+        if (!response.ok) throw new Error("Failed to fetch low-stock products");
+        return response.json();
+      },
+      // low — low stock status changes frequently
+      ...getCacheTier("low")
+    });
+  } catch (error) {
+    logger.warn("[useLowStockProducts] Called outside QueryClientProvider, returning empty list");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+function useStorefrontProducts(params) {
+  try {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.set("page", params.page.toString());
+    if (params?.pageSize) queryParams.set("pageSize", params.pageSize.toString());
+    if (params?.collectionSlug) queryParams.set("collectionSlug", params.collectionSlug);
+    if (params?.search) queryParams.set("search", params.search);
+    return useQuery10({
+      queryKey: productKeys.list(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products?${queryParams.toString()}`);
+        if (!response.ok) throw new Error("Failed to fetch products");
+        return response.json();
+      },
+      // medium — product catalog changes infrequently
+      ...getCacheTier("medium")
+    });
+  } catch (error) {
+    logger.warn("[useStorefrontProducts] Called outside QueryClientProvider, returning empty list");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+function useProduct(slug) {
+  try {
+    return useQuery10({
+      queryKey: productKeys.detail(slug),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/${slug}`);
+        if (!response.ok) throw new Error("Failed to fetch product");
+        return response.json();
+      },
+      // medium — product details change infrequently
+      ...getCacheTier("medium"),
+      enabled: !!slug
+    });
+  } catch (error) {
+    logger.warn("[useProduct] Called outside QueryClientProvider, returning undefined");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+function useRecommendedProducts(params) {
+  try {
+    const queryParams = new URLSearchParams();
+    if (params?.page) queryParams.set("page", params.page.toString());
+    if (params?.pageSize) queryParams.set("pageSize", params.pageSize.toString());
+    if (params?.excludeProductId) queryParams.set("excludeProductId", params.excludeProductId);
+    return useQuery10({
+      queryKey: productKeys.recommended(params),
+      queryFn: async () => {
+        const response = await fetch(`/api/products/recommended?${queryParams.toString()}`);
+        if (!response.ok) throw new Error("Failed to fetch recommended products");
+        return response.json();
+      },
+      // medium — recommendations change infrequently
+      ...getCacheTier("medium")
+    });
+  } catch (error) {
+    logger.warn("[useRecommendedProducts] Called outside QueryClientProvider, returning empty list");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+
+// src/hooks/use-wishlist.ts
+import { useQuery as useQuery11, useMutation as useMutation4, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+
+// src/services/wishlist.service.ts
+import { GraphQLClient } from "graphql-request";
+var GET_STOREFRONT_WISHLIST = `
+  query GetStorefrontWishlist($page: Int!, $pageSize: Int!) {
+    storefront_wishlist(page: $page, pageSize: $pageSize) {
+      items {
+        id
+        product_id
+        notes
+        created_at
+        product_name
+        product_slug
+        product_price
+        currency
+        product_image
+      }
+      total
+      page
+      page_size
+      total_pages
+    }
+  }
+`;
+var CHECK_IN_STOREFRONT_WISHLIST = `
+  query CheckInStorefrontWishlist($productId: String!) {
+    check_in_storefront_wishlist(productId: $productId) {
+      in_wishlist
+    }
+  }
+`;
+function createGraphQLClient(config, accessToken) {
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json",
+    "X-Storefront-Key": config.storefrontApiKey,
+    "X-Business-ID": config.businessId
+  };
+  if (accessToken) {
+    headers["Authorization"] = `Bearer ${accessToken}`;
+  }
+  return new GraphQLClient(`${config.backendUrls.store}/graphql`, { headers });
+}
+async function getWishlist(config, accessToken, params) {
+  const client = createGraphQLClient(config, accessToken);
+  const variables = {
+    page: params?.page || 1,
+    pageSize: params?.pageSize || 20
+  };
+  const data = await client.request(GET_STOREFRONT_WISHLIST, variables);
+  return data.storefront_wishlist;
+}
+async function checkInWishlist(config, accessToken, productId) {
+  const client = createGraphQLClient(config, accessToken);
+  const data = await client.request(CHECK_IN_STOREFRONT_WISHLIST, { productId });
+  return data.check_in_storefront_wishlist;
+}
+async function addToWishlist(config, accessToken, productId, notes) {
+  const response = await fetch(`${config.backendUrls.store}/wishlist/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({
+      product_id: productId,
+      notes: notes || void 0
+    })
+  });
+  if (!response.ok) throw new Error("Failed to add to wishlist");
+  return response.json();
+}
+async function removeFromWishlist(config, accessToken, itemId) {
+  const response = await fetch(`${config.backendUrls.store}/wishlist/${itemId}`, {
+    method: "DELETE",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to remove from wishlist");
+}
+async function removeProductFromWishlist(config, accessToken, productId) {
+  const response = await fetch(`${config.backendUrls.store}/wishlist/product/${productId}`, {
+    method: "DELETE",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to remove product from wishlist");
+}
+
+// src/hooks/use-wishlist.ts
+var wishlistKeys = {
+  all: ["wishlist"],
+  list: () => [...wishlistKeys.all, "list"],
+  check: (productId) => [...wishlistKeys.all, "check", productId]
+};
+function useWishlist(arg1, arg2, arg3) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null && "businessId" in arg1;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const explicitToken = isArg1Config ? arg2 : void 0;
+  const params = isArg1Config ? arg3 : arg1;
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx);
+    return useQuery11({
+      queryKey: [...wishlistKeys.list(), params],
+      queryFn: () => token ? getWishlist(cfg, token, params) : Promise.resolve(void 0),
+      enabled: !!token,
+      ...getCacheTier("medium")
+    });
+  } catch (error) {
+    console.warn("[useWishlist] Called outside QueryClientProvider, returning empty wishlist");
+    return { data: void 0, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: void 0 }) };
+  }
+}
+function useCheckInWishlist(arg1, arg2, arg3) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null && "businessId" in arg1;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const explicitToken = isArg1Config ? arg2 : void 0;
+  const productId = isArg1Config ? arg3 : typeof arg1 === "string" ? arg1 : void 0;
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx);
+    return useQuery11({
+      queryKey: wishlistKeys.check(productId ?? ""),
+      queryFn: () => token && productId ? checkInWishlist(cfg, token, productId) : Promise.resolve({ in_wishlist: false }),
+      ...getCacheTier("low"),
+      enabled: !!productId && !!token
+    });
+  } catch (error) {
+    console.warn("[useCheckInWishlist] Called outside QueryClientProvider, returning false");
+    return { data: false, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: false }) };
+  }
+}
+function useAddToWishlist(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient4();
+    return useMutation4({
+      mutationFn: ({ productId, notes }) => token ? addToWishlist(cfg, token, productId, notes) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: wishlistKeys.all });
+        queryClient.invalidateQueries({ queryKey: ["wishlist", "check"] });
+      }
+    });
+  } catch (error) {
+    console.warn("[useAddToWishlist] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+function useRemoveFromWishlist(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient4();
+    return useMutation4({
+      mutationFn: (itemId) => token ? removeFromWishlist(cfg, token, itemId) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: wishlistKeys.all });
+        queryClient.invalidateQueries({ queryKey: ["wishlist", "check"] });
+      }
+    });
+  } catch (error) {
+    console.warn("[useRemoveFromWishlist] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+function useRemoveProductFromWishlist(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient4();
+    return useMutation4({
+      mutationFn: (productId) => token ? removeProductFromWishlist(cfg, token, productId) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: wishlistKeys.all });
+        queryClient.invalidateQueries({ queryKey: ["wishlist", "check"] });
+      }
+    });
+  } catch (error) {
+    console.warn("[useRemoveProductFromWishlist] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+
+// src/hooks/use-service-booking.ts
+import { useQuery as useQuery12, useMutation as useMutation5, useQueryClient as useQueryClient5 } from "@tanstack/react-query";
+
+// src/services/service-booking.service.ts
+async function getAvailableSlots(config, product_id, date_from, date_to) {
+  const response = await fetch(
+    `${config.backendUrls.store}/service/available-slots/${product_id}?date_from=${date_from}&date_to=${date_to}`,
+    {
+      headers: {
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      }
+    }
+  );
+  if (!response.ok) throw new Error("Failed to get available slots");
+  return response.json();
+}
+async function bookAppointment(config, accessToken, payload) {
+  const response = await fetch(`${config.backendUrls.store}/service/appointments/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) throw new Error("Failed to book appointment");
+  return response.json();
+}
+async function getAppointments(config, accessToken) {
+  const response = await fetch(`${config.backendUrls.store}/service/bookings/my`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get appointments");
+  return response.json();
+}
+async function getAppointment(config, accessToken, id) {
+  const response = await fetch(`${config.backendUrls.store}/service/bookings/${id}`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get appointment");
+  return response.json();
+}
+async function cancelAppointment(config, accessToken, id) {
+  await fetch(`${config.backendUrls.store}/service/bookings/${id}`, {
+    method: "DELETE",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+}
+async function getDeliverables(config, accessToken, order_id) {
+  const response = await fetch(`${config.backendUrls.store}/service/projects/${order_id}/deliverables/`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get deliverables");
+  return response.json();
+}
+async function approveDeliverable(config, accessToken, order_id, deliverable_id) {
+  const response = await fetch(
+    `${config.backendUrls.store}/service/projects/${order_id}/deliverables/${deliverable_id}/approve`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${accessToken}`,
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      },
+      body: JSON.stringify({ approved: true })
+    }
+  );
+  if (!response.ok) throw new Error("Failed to approve deliverable");
+  return response.json();
+}
+async function requestRevision(config, accessToken, order_id, deliverable_id, feedback) {
+  const response = await fetch(
+    `${config.backendUrls.store}/service/projects/${order_id}/deliverables/${deliverable_id}/revision`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${accessToken}`,
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      },
+      body: JSON.stringify({ approved: false, feedback })
+    }
+  );
+  if (!response.ok) throw new Error("Failed to request revision");
+  return response.json();
+}
+
+// src/hooks/use-service-booking.ts
+function useAvailableSlots(arg1, arg2, arg3, arg4) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null && "businessId" in arg1;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const product_id = isArg1Config ? arg2 : typeof arg1 === "string" ? arg1 : void 0;
+  const date_from = isArg1Config ? arg3 : typeof arg2 === "string" ? arg2 : void 0;
+  const date_to = isArg1Config ? arg4 : typeof arg3 === "string" ? arg3 : void 0;
+  try {
+    const { config: cfg } = resolveHookArgs(explicitConfig, void 0, ctx);
+    return useQuery12({
+      queryKey: ["available-slots", product_id, date_from, date_to],
+      queryFn: () => getAvailableSlots(cfg, product_id, date_from, date_to),
+      enabled: !!product_id && !!date_from && !!date_to
+    });
+  } catch (error) {
+    logger.warn("[useAvailableSlots] Called outside QueryClientProvider, returning undefined");
+    return { data: void 0, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: void 0 }) };
+  }
+}
+function useBookAppointment(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient5();
+    return useMutation5({
+      mutationFn: (payload) => token ? bookAppointment(cfg, token, payload) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["appointments"] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useBookAppointment] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+function useAppointments(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    return useQuery12({
+      queryKey: ["appointments"],
+      queryFn: () => token ? getAppointments(cfg, token) : Promise.resolve([]),
+      enabled: !!token
+    });
+  } catch (error) {
+    logger.warn("[useAppointments] Called outside QueryClientProvider, returning empty list");
+    return { data: void 0, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: void 0 }) };
+  }
+}
+function useAppointment(arg1, arg2, arg3) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null && "businessId" in arg1;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const explicitToken = isArg1Config ? arg2 : void 0;
+  const id = isArg1Config ? arg3 : typeof arg1 === "string" ? arg1 : void 0;
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx);
+    return useQuery12({
+      queryKey: ["appointment", id],
+      queryFn: () => token && id ? getAppointment(cfg, token, id) : Promise.resolve(void 0),
+      enabled: !!id && !!token
+    });
+  } catch (error) {
+    logger.warn("[useAppointment] Called outside QueryClientProvider, returning undefined");
+    return { data: void 0, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: void 0 }) };
+  }
+}
+function useCancelAppointment(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient5();
+    return useMutation5({
+      mutationFn: (id) => token ? cancelAppointment(cfg, token, id) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["appointments"] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useCancelAppointment] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+function useDeliverables(arg1, arg2, arg3) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null && "businessId" in arg1;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const explicitToken = isArg1Config ? arg2 : void 0;
+  const order_id = isArg1Config ? arg3 : typeof arg1 === "string" ? arg1 : void 0;
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx);
+    return useQuery12({
+      queryKey: ["deliverables", order_id],
+      queryFn: () => token && order_id ? getDeliverables(cfg, token, order_id) : Promise.resolve([]),
+      enabled: !!order_id && !!token
+    });
+  } catch (error) {
+    logger.warn("[useDeliverables] Called outside QueryClientProvider, returning empty list");
+    return { data: void 0, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: void 0 }) };
+  }
+}
+function useApproveDeliverable(config, accessToken, order_id, deliverable_id) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient5();
+    return useMutation5({
+      mutationFn: () => token && order_id && deliverable_id ? approveDeliverable(cfg, token, order_id, deliverable_id) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["deliverables", order_id] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useApproveDeliverable] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+function useRequestRevision(config, accessToken, order_id, deliverable_id) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient5();
+    return useMutation5({
+      mutationFn: (feedback) => token && order_id && deliverable_id ? requestRevision(cfg, token, order_id, deliverable_id, feedback) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["deliverables", order_id] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useRequestRevision] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+
+// src/hooks/use-consultations.ts
+import { useQuery as useQuery13, useMutation as useMutation6, useQueryClient as useQueryClient6 } from "@tanstack/react-query";
+
+// src/services/consultation.service.ts
+async function createConsultation(config, accessToken, payload) {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) throw new Error("Failed to create consultation");
+  return response.json();
+}
+async function getConsultations(config, accessToken) {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get consultations");
+  return response.json();
+}
+async function getConsultation(config, accessToken, id) {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/${id}`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get consultation");
+  return response.json();
+}
+async function sendMessage(config, accessToken, id, payload) {
+  await fetch(`${config.backendUrls.store}/social/consultations/${id}/messages`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+}
+async function acceptQuote(config, accessToken, id, payload) {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/${id}/accept-quote`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) throw new Error("Failed to accept quote");
+  return response.json();
+}
+async function rejectQuote(config, accessToken, id, reason) {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/${id}/reject-quote`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({ reason })
+  });
+  if (!response.ok) throw new Error("Failed to reject quote");
+  return response.json();
+}
+
+// src/hooks/use-consultations.ts
+function useConsultations(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    return useQuery13({
+      queryKey: ["consultations"],
+      queryFn: () => token ? getConsultations(cfg, token) : Promise.resolve([]),
+      enabled: !!token
+    });
+  } catch (error) {
+    logger.warn("[useConsultations] Called outside QueryClientProvider, returning empty list");
+    return { data: void 0, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: void 0 }) };
+  }
+}
+function useConsultation(arg1, arg2, arg3) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const explicitToken = isArg1Config ? arg2 : void 0;
+  const id = isArg1Config ? arg3 : typeof arg1 === "string" ? arg1 : void 0;
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx);
+    return useQuery13({
+      queryKey: ["consultation", id],
+      queryFn: () => token && id ? getConsultation(cfg, token, id) : Promise.resolve(void 0),
+      enabled: !!id && !!token
+    });
+  } catch (error) {
+    logger.warn("[useConsultation] Called outside QueryClientProvider, returning undefined");
+    return { data: void 0, isLoading: false, error: null, isFetching: false, refetch: () => Promise.resolve({ data: void 0 }) };
+  }
+}
+function useCreateConsultation(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient6();
+    return useMutation6({
+      mutationFn: (payload) => token ? createConsultation(cfg, token, payload) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["consultations"] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useCreateConsultation] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+function useSendMessage(arg1, arg2, arg3) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const explicitToken = isArg1Config ? arg2 : void 0;
+  const consultationId = isArg1Config ? arg3 : typeof arg1 === "string" ? arg1 : void 0;
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx);
+    const queryClient = useQueryClient6();
+    return useMutation6({
+      mutationFn: (payload) => token && consultationId ? sendMessage(cfg, token, consultationId, payload) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["consultation", consultationId] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useSendMessage] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+function useAcceptQuote(arg1, arg2, arg3) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const explicitToken = isArg1Config ? arg2 : void 0;
+  const consultationId = isArg1Config ? arg3 : typeof arg1 === "string" ? arg1 : void 0;
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx);
+    const queryClient = useQueryClient6();
+    return useMutation6({
+      mutationFn: (payload) => token && consultationId ? acceptQuote(cfg, token, consultationId, payload) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["consultation", consultationId] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useAcceptQuote] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+function useRejectQuote(arg1, arg2, arg3) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const explicitToken = isArg1Config ? arg2 : void 0;
+  const consultationId = isArg1Config ? arg3 : typeof arg1 === "string" ? arg1 : void 0;
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(explicitConfig, explicitToken, ctx);
+    const queryClient = useQueryClient6();
+    return useMutation6({
+      mutationFn: (reason) => token && consultationId ? rejectQuote(cfg, token, consultationId, reason) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["consultation", consultationId] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useRejectQuote] Called outside QueryClientProvider, returning no-op mutation");
+    return { mutate: () => {
+    }, mutateAsync: () => Promise.resolve(void 0) };
+  }
+}
+
+// src/hooks/use-consultation-stream.ts
+import { useEffect, useRef, useState as useState2 } from "react";
+import { fetchEventSource } from "@microsoft/fetch-event-source";
+function useConsultationStream({
+  config,
+  consultationId,
+  onMessage,
+  onQuote,
+  onStatusChange,
+  onError
+}) {
+  const abortControllerRef = useRef(null);
+  const [isConnected, setIsConnected] = useState2(false);
+  const [lastEvent, setLastEvent] = useState2(null);
+  useEffect(() => {
+    if (!consultationId) {
+      return;
+    }
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+    const streamUrl = `${config.backendUrls.payment}/events/stream/consultation/${consultationId}`;
+    fetchEventSource(streamUrl, {
+      method: "GET",
+      signal: abortController.signal,
+      onmessage: (event) => {
+        try {
+          if (!event.data || event.data.trim() === "") {
+            return;
+          }
+          const data = JSON.parse(event.data);
+          logger.log("[ConsultationStream] Received event:", data);
+          setLastEvent(data);
+          if (data.event === "consultation.message") {
+            logger.log("[ConsultationStream] Message detected, calling onMessage");
+            if (onMessage) {
+              onMessage(data);
+            }
+          }
+          if (data.event === "consultation.quote") {
+            logger.log("[ConsultationStream] Quote detected, calling onQuote");
+            if (onQuote) {
+              onQuote(data);
+            }
+          }
+          if (data.event === "consultation.status") {
+            logger.log("[ConsultationStream] Status change detected, calling onStatusChange");
+            if (onStatusChange) {
+              onStatusChange(data);
+            }
+          }
+        } catch (error) {
+          logger.error("[ConsultationStream] Error parsing event:", error);
+        }
+      },
+      onerror: (error) => {
+        if (abortController.signal.aborted) {
+          logger.log("[ConsultationStream] Connection closed via AbortController");
+          return;
+        }
+        logger.error("[ConsultationStream] Connection error:", error);
+        setIsConnected(false);
+        if (onError) {
+          onError(error);
+        }
+      },
+      onopen: async (response) => {
+        if (response.ok && response.headers.get("content-type")?.includes("text/event-stream")) {
+          logger.log("[ConsultationStream] Connection established for consultation:", consultationId);
+          setIsConnected(true);
+          return;
+        }
+        throw new Error(`Unexpected response: ${response.status}`);
+      }
+    }).catch((error) => {
+      if (abortController.signal.aborted || error.name === "AbortError") {
+        return;
+      }
+      logger.error("[ConsultationStream] fetchEventSource failed:", error);
+    });
+    return () => {
+      abortController.abort();
+      setIsConnected(false);
+    };
+  }, [consultationId, onMessage, onQuote, onStatusChange, onError]);
+  return { isConnected, lastEvent };
+}
+
+// src/hooks/use-order-stream.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import { fetchEventSource as fetchEventSource2 } from "@microsoft/fetch-event-source";
+function useOrderStream({
+  config: explicitConfig,
+  orderId,
+  onPaymentComplete,
+  onDigitalReady,
+  onBespokeUpdate,
+  onConsultationUpdate,
+  onServiceBookingUpdate,
+  onError
+}) {
+  const ctx = useSdkContext();
+  const config = explicitConfig ?? ctx?.config;
+  const abortControllerRef = useRef2(null);
+  useEffect2(() => {
+    if (!orderId || !config) {
+      return;
+    }
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+    const streamUrl = `${config.backendUrls.payment}/events/stream/order/${encodeURIComponent(orderId)}`;
+    fetchEventSource2(streamUrl, {
+      method: "GET",
+      signal: abortController.signal,
+      onmessage: (event) => {
+        try {
+          if (!event.data || event.data.trim() === "") {
+            return;
+          }
+          const data = JSON.parse(event.data);
+          logger.log("[OrderStream] Received event:", data);
+          if (data.event === "payment.success") {
+            logger.log("[OrderStream] Payment success detected, calling onPaymentComplete");
+            if (onPaymentComplete) {
+              onPaymentComplete(data);
+            }
+            abortController.abort();
+          }
+          if (data.event === "digital.ready") {
+            logger.log("[OrderStream] Digital delivery ready detected, calling onDigitalReady");
+            if (onDigitalReady) {
+              onDigitalReady(data);
+            }
+          }
+          if (data.event === "bespoke.update") {
+            logger.log("[OrderStream] Bespoke update detected, calling onBespokeUpdate");
+            if (onBespokeUpdate) {
+              onBespokeUpdate(data);
+            }
+          }
+          if (data.event === "consultation.update") {
+            logger.log("[OrderStream] Consultation update detected, calling onConsultationUpdate");
+            if (onConsultationUpdate) {
+              onConsultationUpdate(data);
+            }
+          }
+          if (data.event === "service_booking.update") {
+            logger.log("[OrderStream] Service booking update detected, calling onServiceBookingUpdate");
+            if (onServiceBookingUpdate) {
+              onServiceBookingUpdate(data);
+            }
+          }
+        } catch (error) {
+          logger.error("[OrderStream] Error parsing event:", error);
+        }
+      },
+      onerror: (error) => {
+        if (abortController.signal.aborted) {
+          logger.log("[OrderStream] Connection closed via AbortController");
+          return;
+        }
+        if (error.message?.includes("404") || error.message?.includes("Not Found")) {
+          logger.warn("[OrderStream] Stream endpoint unavailable for order:", orderId);
+          return;
+        }
+        logger.error("[OrderStream] Connection error:", error);
+        if (onError) {
+          onError(error);
+        }
+      },
+      onopen: async (response) => {
+        if (response.ok && response.headers.get("content-type")?.includes("text/event-stream")) {
+          logger.log("[OrderStream] Connection established for order:", orderId);
+          return;
+        }
+        if (response.status === 404) {
+          logger.warn("[OrderStream] Stream endpoint unavailable for order:", orderId);
+          return;
+        }
+        throw new Error(`Unexpected response: ${response.status}`);
+      }
+    }).catch((error) => {
+      if (abortController.signal.aborted || error.name === "AbortError") {
+        return;
+      }
+      logger.error("[OrderStream] fetchEventSource failed:", error);
+    });
+    return () => {
+      abortController.abort();
+    };
+  }, [orderId, onPaymentComplete, onDigitalReady, onBespokeUpdate, onConsultationUpdate, onServiceBookingUpdate, onError]);
+  return null;
+}
+
+// src/hooks/use-is-mounted.ts
+import { useEffect as useEffect3, useState as useState3 } from "react";
+function useIsMounted() {
+  const [mounted, setMounted] = useState3(false);
+  useEffect3(() => {
+    setMounted(true);
+  }, []);
+  return mounted;
+}
+
+// src/hooks/use-mobile.ts
+import { useEffect as useEffect4, useState as useState4 } from "react";
+var MOBILE_BREAKPOINT = 768;
+function useIsMobile() {
+  const [isMobile, setIsMobile] = useState4(false);
+  useEffect4(() => {
+    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+    const onChange = () => setIsMobile(mql.matches);
+    mql.addEventListener("change", onChange);
+    setIsMobile(mql.matches);
+    return () => mql.removeEventListener("change", onChange);
+  }, []);
+  return isMobile;
+}
+
+// src/hooks/use-google-translate.ts
+import { useEffect as useEffect5, useCallback, useState as useState5, useRef as useRef3 } from "react";
+var SCRIPT_ID = "google-translate-script";
+var ELEMENT_ID = "google_translate_element";
+function fireChange(googleCode) {
+  const combo = document.querySelector(".goog-te-combo");
+  if (combo) {
+    combo.value = googleCode;
+    combo.dispatchEvent(new Event("change"));
+    return true;
+  }
+  return false;
+}
+function useGoogleTranslate(configOrLang, appLang) {
+  const ctx = useSdkContext();
+  let cfg;
+  let lang;
+  if (typeof configOrLang === "string") {
+    lang = configOrLang;
+    cfg = resolveHookArgs(void 0, void 0, ctx).config;
+  } else {
+    lang = appLang ?? "en";
+    cfg = resolveHookArgs(configOrLang, void 0, ctx).config;
+  }
+  const [isLoaded, setIsLoaded] = useState5(false);
+  const initRef = useRef3(false);
+  const { data: supportedLangs = [] } = useSupportedLanguages(cfg);
+  const clearCookies = useCallback(() => {
+    if (typeof window === "undefined") return;
+    const domains = [
+      window.location.hostname,
+      "." + window.location.hostname,
+      "." + window.location.hostname.split(".").slice(-2).join(".")
+    ];
+    const path = "/";
+    document.cookie = `googtrans=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=${path};`;
+    domains.forEach((domain) => {
+      document.cookie = `googtrans=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=${path}; domain=${domain};`;
+    });
+  }, []);
+  const resetToEnglish = useCallback(() => {
+    if (typeof window === "undefined") return;
+    const googtrans = document.cookie.split("; ").find((row) => row.startsWith("googtrans="))?.split("=")[1];
+    const domains = [
+      window.location.hostname,
+      "." + window.location.hostname,
+      window.location.hostname.split(".").slice(-2).join("."),
+      "." + window.location.hostname.split(".").slice(-2).join(".")
+    ];
+    const clear = (name) => {
+      document.cookie = `${name}=; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT;`;
+      domains.forEach((d) => {
+        document.cookie = `${name}=; Path=/; Domain=${d}; Expires=Thu, 01 Jan 1970 00:00:01 GMT;`;
+      });
+    };
+    clear("googtrans");
+    if (googtrans || document.documentElement.classList.contains("translated-ltr") || document.querySelector(".goog-te-banner-frame")) {
+      window.location.reload();
+      return;
+    }
+    document.body.style.top = "0";
+    document.documentElement.classList.remove("translated-ltr", "translated-rtl");
+    const container = document.getElementById(":1.container");
+    if (container) container.style.display = "none";
+  }, []);
+  const changeLanguage = useCallback((nextAppCode) => {
+    if (nextAppCode === "en") {
+      resetToEnglish();
+      return;
+    }
+    const googleCode = nextAppCode;
+    const container = document.getElementById(":1.container");
+    if (container) container.style.display = "block";
+    let tries = 0;
+    const tick = () => {
+      if (fireChange(googleCode)) return;
+      if (tries++ < 30) setTimeout(tick, 200);
+    };
+    tick();
+  }, [resetToEnglish]);
+  useEffect5(() => {
+    if (typeof window === "undefined") return;
+    if (lang === "en" && !initRef.current) return;
+    if (initRef.current) return;
+    if (supportedLangs.length === 0) return;
+    initRef.current = true;
+    if (!document.getElementById(ELEMENT_ID)) {
+      const host = document.createElement("div");
+      host.id = ELEMENT_ID;
+      host.style.display = "none";
+      document.body.appendChild(host);
+    }
+    const includedLanguages = supportedLangs.map((l) => l.code).join(",");
+    window.googleTranslateElementInit = () => {
+      if (window.google?.translate?.TranslateElement) {
+        new window.google.translate.TranslateElement(
+          { pageLanguage: "en", includedLanguages, autoDisplay: false },
+          ELEMENT_ID
+        );
+        setIsLoaded(true);
+      }
+    };
+    if (!document.getElementById(SCRIPT_ID)) {
+      const script = document.createElement("script");
+      script.id = SCRIPT_ID;
+      script.src = "//translate.google.com/translate_a/element.js?cb=googleTranslateElementInit";
+      script.async = true;
+      document.body.appendChild(script);
+    } else {
+      if (window.google?.translate) window.googleTranslateElementInit?.();
+    }
+  }, [lang, supportedLangs]);
+  useEffect5(() => {
+    if (isLoaded || lang === "en" && initRef.current) {
+      changeLanguage(lang);
+    }
+  }, [lang, isLoaded, changeLanguage]);
+  return { isLoaded };
+}
+
+// src/hooks/use-payment.ts
+import { useQuery as useQuery14, useMutation as useMutation7, useQueryClient as useQueryClient7 } from "@tanstack/react-query";
+
+// src/services/payment.service.ts
+async function createDedicatedAccount(config, accessToken, request) {
+  const isValidUUID = (str) => {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(str);
+  };
+  const response = await fetch(`${config.backendUrls.payment}/payments/dedicated-account`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({
+      order_id: request.order_id && isValidUUID(request.order_id) ? request.order_id : void 0,
+      amount: request.amount,
+      customer_email: request.customer_email,
+      customer_name: request.customer_name,
+      currency: request.currency,
+      idempotency_key: request.idempotency_key
+    })
+  });
+  if (!response.ok) throw new Error("Failed to create dedicated account");
+  const data = await response.json();
+  return data;
+}
+async function initiatePayment(config, accessToken, request) {
+  const isValidUUID = (str) => {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(str);
+  };
+  const validOrderId = request.order_id && isValidUUID(request.order_id) ? request.order_id : void 0;
+  const response = await fetch(`${config.backendUrls.payment}/payments/storefront/initiate`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    },
+    body: JSON.stringify({
+      amount: request.amount,
+      currency: request.currency,
+      order_id: validOrderId,
+      quote_id: request.quote_id,
+      metadata_json: {
+        customer_email: request.customer_email,
+        customer_name: request.customer_name ?? "",
+        order_id: validOrderId,
+        ...request.metadata ?? {}
+      },
+      idempotency_key: request.idempotency_key
+    })
+  });
+  if (!response.ok) throw new Error("Failed to initiate payment");
+  const data = await response.json();
+  return {
+    id: data.id,
+    gateway_ref: data.gateway_ref,
+    gateway: data.gateway,
+    status: data.status,
+    checkout_url: data.metadata_json?.checkout_url ?? ""
+  };
+}
+async function verifyTransaction(configOrReference, reference) {
+  if (typeof configOrReference === "string") {
+    const ref2 = configOrReference;
+    const response2 = await fetch(`/api/payments/verify/${ref2}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response2.ok) throw new Error("Failed to verify transaction");
+    return response2.json();
+  }
+  const config = configOrReference;
+  const ref = reference || "";
+  const response = await fetch(`${config.backendUrls.payment}/payments/verify/${ref}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to verify transaction");
+  const data = await response.json();
+  return data;
+}
+async function getTransactionStatus(config, transactionId) {
+  const response = await fetch(`${config.backendUrls.payment}/payments/transactions/${transactionId}`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId
+    }
+  });
+  if (!response.ok) throw new Error("Failed to get transaction status");
+  const data = await response.json();
+  return data;
+}
+
+// src/hooks/use-payment.ts
+function useCreateDVA(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient7();
+    return useMutation7({
+      mutationFn: (request) => token ? createDedicatedAccount(cfg, token, request) : Promise.reject("No access token"),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["payment"] });
+      }
+    });
+  } catch (error) {
+    logger.warn("[useCreateDVA] Called outside QueryClientProvider, returning no-op mutation");
+    return {
+      mutate: () => {
+      },
+      mutateAsync: () => Promise.resolve(void 0)
+    };
+  }
+}
+function useInitiatePayment(config, accessToken) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    return useMutation7({
+      mutationFn: (request) => token ? initiatePayment(cfg, token, request) : Promise.reject("No access token")
+    });
+  } catch (error) {
+    logger.warn("[useInitiatePayment] Called outside QueryClientProvider, returning no-op mutation");
+    return {
+      mutate: () => {
+      },
+      mutateAsync: () => Promise.resolve(void 0)
+    };
+  }
+}
+function useVerifyTransaction(config) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg } = resolveHookArgs(config, void 0, ctx);
+    return useMutation7({
+      mutationFn: (reference) => verifyTransaction(cfg, reference)
+    });
+  } catch (error) {
+    logger.warn("[useVerifyTransaction] Called outside QueryClientProvider, returning no-op mutation");
+    return {
+      mutate: () => {
+      },
+      mutateAsync: () => Promise.resolve(void 0)
+    };
+  }
+}
+function useTransactionStatus(arg1, arg2, arg3) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null && "businessId" in arg1;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const transactionId = isArg1Config ? arg2 : typeof arg1 === "string" ? arg1 : "";
+  const enabled = isArg1Config ? arg3 ?? false : typeof arg2 === "boolean" ? arg2 : false;
+  try {
+    const { config: cfg } = resolveHookArgs(explicitConfig, void 0, ctx);
+    return useQuery14({
+      queryKey: ["transaction", "status", transactionId],
+      queryFn: () => getTransactionStatus(cfg, transactionId),
+      enabled: enabled && !!transactionId,
+      refetchInterval: 3e3
+    });
+  } catch (error) {
+    logger.warn("[useTransactionStatus] Called outside QueryClientProvider, returning undefined");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+function usePollTransactionStatus(arg1, arg2, arg3) {
+  const ctx = useSdkContext();
+  const isArg1Config = typeof arg1 === "object" && arg1 !== null && "businessId" in arg1;
+  const explicitConfig = isArg1Config ? arg1 : void 0;
+  const reference = isArg1Config ? arg2 : typeof arg1 === "string" ? arg1 : "";
+  const enabled = isArg1Config ? arg3 ?? false : typeof arg2 === "boolean" ? arg2 : false;
+  try {
+    const { config: cfg } = resolveHookArgs(explicitConfig, void 0, ctx);
+    return useQuery14({
+      queryKey: ["transaction", "poll", reference],
+      queryFn: () => verifyTransaction(cfg, reference),
+      enabled: enabled && !!reference,
+      refetchInterval: 2e3,
+      retry: 10
+    });
+  } catch (error) {
+    logger.warn("[usePollTransactionStatus] Called outside QueryClientProvider, returning undefined");
+    return {
+      data: void 0,
+      isLoading: false,
+      error: null,
+      isFetching: false,
+      refetch: () => Promise.resolve({ data: void 0 })
+    };
+  }
+}
+
+// src/hooks/use-cms.ts
+import { useQuery as useQuery15, useMutation as useMutation8, useQueryClient as useQueryClient8 } from "@tanstack/react-query";
+
+// src/services/cms.service.ts
+async function listCmsEntries(config, modelSlug, params) {
+  const queryParams = new URLSearchParams();
+  queryParams.set("page", (params?.page || 1).toString());
+  queryParams.set("page_size", (params?.page_size || 50).toString());
+  const response = await fetch(
+    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries?${queryParams.toString()}`,
+    {
+      headers: {
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      }
+    }
+  );
+  if (!response.ok) throw new Error("Failed to list CMS entries");
+  return response.json();
+}
+async function getCmsEntry(config, modelSlug, entryId) {
+  const response = await fetch(
+    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries/${entryId}`,
+    {
+      headers: {
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      }
+    }
+  );
+  if (!response.ok) throw new Error("Failed to get CMS entry");
+  return response.json();
+}
+async function createCmsEntry(config, accessToken, modelSlug, params) {
+  const response = await fetch(
+    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${accessToken}`,
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      },
+      body: JSON.stringify(params)
+    }
+  );
+  if (!response.ok) throw new Error("Failed to create CMS entry");
+  return response.json();
+}
+async function updateCmsEntry(config, accessToken, modelSlug, entryId, params) {
+  const response = await fetch(
+    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries/${entryId}`,
+    {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${accessToken}`,
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      },
+      body: JSON.stringify(params)
+    }
+  );
+  if (!response.ok) throw new Error("Failed to update CMS entry");
+  return response.json();
+}
+async function deleteCmsEntry(config, accessToken, modelSlug, entryId) {
+  const response = await fetch(
+    `${config.backendUrls.cms}/sdk/${config.businessId}/${modelSlug}/entries/${entryId}`,
+    {
+      method: "DELETE",
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "X-Storefront-Key": config.storefrontApiKey,
+        "X-Business-ID": config.businessId
+      }
+    }
+  );
+  if (!response.ok) throw new Error("Failed to delete CMS entry");
+}
+
+// src/hooks/use-cms.ts
+function useCmsEntries(configOrModelSlug, modelSlugOrParams, maybeParams) {
+  const ctx = useSdkContext();
+  let cfg;
+  let slug;
+  let params;
+  if (typeof configOrModelSlug === "string") {
+    slug = configOrModelSlug;
+    params = modelSlugOrParams;
+    cfg = resolveHookArgs(void 0, void 0, ctx).config;
+  } else {
+    cfg = configOrModelSlug;
+    slug = modelSlugOrParams;
+    params = maybeParams;
+  }
+  try {
+    const query = useQuery15({
+      queryKey: ["cms-entries", slug, params],
+      queryFn: () => listCmsEntries(cfg, slug, params),
+      enabled: !!slug
+    });
+    return {
+      entries: query.data?.entries || [],
+      total: query.data?.total || 0,
+      page: query.data?.page || 1,
+      page_size: query.data?.page_size || 50,
+      isLoading: query.isLoading,
+      error: query.error,
+      refetch: query.refetch
+    };
+  } catch (error) {
+    logger.warn("[useCmsEntries] Called outside QueryClientProvider, returning empty list");
+    return {
+      entries: [],
+      total: 0,
+      page: 1,
+      page_size: 50,
+      isLoading: false,
+      error: null,
+      refetch: () => {
+      }
+    };
+  }
+}
+function useCmsEntry(configOrModelSlug, modelSlugOrEntryId, maybeEntryId) {
+  const ctx = useSdkContext();
+  let cfg;
+  let slug;
+  let entryId;
+  if (maybeEntryId !== void 0) {
+    cfg = configOrModelSlug;
+    slug = modelSlugOrEntryId;
+    entryId = maybeEntryId;
+  } else {
+    cfg = resolveHookArgs(void 0, void 0, ctx).config;
+    slug = configOrModelSlug;
+    entryId = modelSlugOrEntryId;
+  }
+  try {
+    const query = useQuery15({
+      queryKey: ["cms-entry", slug, entryId],
+      queryFn: () => getCmsEntry(cfg, slug, entryId),
+      enabled: !!slug && !!entryId
+    });
+    return {
+      entry: query.data,
+      isLoading: query.isLoading,
+      error: query.error,
+      refetch: query.refetch
+    };
+  } catch (error) {
+    logger.warn("[useCmsEntry] Called outside QueryClientProvider, returning undefined");
+    return {
+      entry: void 0,
+      isLoading: false,
+      error: null,
+      refetch: () => {
+      }
+    };
+  }
+}
+function useCreateCmsEntry(config, accessToken, modelSlug) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient8();
+    const mutation = useMutation8({
+      mutationFn: (params) => token && modelSlug ? createCmsEntry(cfg, token, modelSlug, params) : Promise.reject("No access token or modelSlug"),
+      onSuccess: () => {
+        if (modelSlug) queryClient.invalidateQueries({ queryKey: ["cms-entries", modelSlug] });
+      }
+    });
+    return {
+      createEntry: mutation.mutate,
+      isLoading: mutation.isPending,
+      error: mutation.error
+    };
+  } catch (error) {
+    logger.warn("[useCreateCmsEntry] Called outside QueryClientProvider, returning no-op mutation");
+    return {
+      createEntry: () => {
+      },
+      isLoading: false,
+      error: null
+    };
+  }
+}
+function useUpdateCmsEntry(config, accessToken, modelSlug) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient8();
+    const mutation = useMutation8({
+      mutationFn: ({ entryId, params }) => token && modelSlug ? updateCmsEntry(cfg, token, modelSlug, entryId, params) : Promise.reject("No access token or modelSlug"),
+      onSuccess: () => {
+        if (modelSlug) {
+          queryClient.invalidateQueries({ queryKey: ["cms-entries", modelSlug] });
+          queryClient.invalidateQueries({ queryKey: ["cms-entry", modelSlug] });
+        }
+      }
+    });
+    return {
+      updateEntry: (entryId, params) => mutation.mutate({ entryId, params }),
+      isLoading: mutation.isPending,
+      error: mutation.error
+    };
+  } catch (error) {
+    logger.warn("[useUpdateCmsEntry] Called outside QueryClientProvider, returning no-op mutation");
+    return {
+      updateEntry: () => {
+      },
+      isLoading: false,
+      error: null
+    };
+  }
+}
+function useDeleteCmsEntry(config, accessToken, modelSlug) {
+  const ctx = useSdkContext();
+  try {
+    const { config: cfg, accessToken: token } = resolveHookArgs(config, accessToken, ctx);
+    const queryClient = useQueryClient8();
+    const mutation = useMutation8({
+      mutationFn: (entryId) => token && modelSlug ? deleteCmsEntry(cfg, token, modelSlug, entryId) : Promise.reject("No access token or modelSlug"),
+      onSuccess: () => {
+        if (modelSlug) {
+          queryClient.invalidateQueries({ queryKey: ["cms-entries", modelSlug] });
+          queryClient.invalidateQueries({ queryKey: ["cms-entry", modelSlug] });
+        }
+      }
+    });
+    return {
+      deleteEntry: mutation.mutate,
+      isLoading: mutation.isPending,
+      error: mutation.error
+    };
+  } catch (error) {
+    logger.warn("[useDeleteCmsEntry] Called outside QueryClientProvider, returning no-op mutation");
+    return {
+      deleteEntry: () => {
+      },
+      isLoading: false,
+      error: null
+    };
+  }
+}
+export {
+  CartCtx,
+  CartProvider,
+  SdkProvider,
+  collectionKeys,
+  getCountries,
+  getStates,
+  getSupportedCurrenciesList,
+  getSupportedLanguagesList,
+  productKeys,
+  resolveHookArgs,
+  useAcceptQuote,
+  useAddToWishlist,
+  useAppointment,
+  useAppointments,
+  useApproveDeliverable,
+  useAuthUser,
+  useAvailableSlots,
+  useBespokeAvailability,
+  useBookAppointment,
+  useCancelAppointment,
+  useCancelOrder,
+  useCart,
+  useCheckInWishlist,
+  useCmsEntries,
+  useCmsEntry,
+  useConsultation,
+  useConsultationStream,
+  useConsultations,
+  useCountries,
+  useCreateCmsEntry,
+  useCreateConsultation,
+  useCreateDVA,
+  useCreateOrder,
+  useCurrencies,
+  useDeleteCmsEntry,
+  useDeliverables,
+  useFeaturedProducts,
+  useFindOrder,
+  useGoogleTranslate,
+  useInitiatePayment,
+  useIsMobile,
+  useIsMounted,
+  useLatestProducts,
+  useLogin,
+  useLogout,
+  useLowStockProducts,
+  useNewProducts,
+  useOnSaleProducts,
+  useOrder,
+  useOrderStream,
+  useOrderTracking,
+  useOrders,
+  useOrdersList,
+  usePollTransactionStatus,
+  usePopularProducts,
+  useProduct,
+  useRecommendedProducts,
+  useRegister,
+  useRejectQuote,
+  useRemoveFromWishlist,
+  useRemoveProductFromWishlist,
+  useRequestRevision,
+  useSdkContext,
+  useSendMessage,
+  useStates,
+  useStorefrontCollection,
+  useStorefrontCollections,
+  useStorefrontProducts,
+  useSupportedLanguages,
+  useTransactionStatus,
+  useUpdateCmsEntry,
+  useUpdateProfile,
+  useVerifyTransaction,
+  useWishlist,
+  wishlistKeys
+};
+//# sourceMappingURL=index.mjs.map