@commercengine/storefront-sdk 0.3.12 → 0.4.0

package/dist/index.cjs

@@ -0,0 +1,2459 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthClient: () => AuthClient,
+  BrowserTokenStorage: () => BrowserTokenStorage,
+  CartClient: () => CartClient,
+  CatalogClient: () => CatalogClient,
+  CookieTokenStorage: () => CookieTokenStorage,
+  CustomerClient: () => CustomerClient,
+  Environment: () => Environment,
+  HelpersClient: () => HelpersClient,
+  MemoryTokenStorage: () => MemoryTokenStorage,
+  OrderClient: () => OrderClient,
+  ResponseUtils: () => ResponseUtils,
+  ShippingClient: () => ShippingClient,
+  StorefrontAPIClient: () => StorefrontAPIClient,
+  StorefrontSDK: () => StorefrontSDK,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/client.ts
+var import_openapi_fetch = __toESM(require("openapi-fetch"), 1);
+
+// src/lib/jwt-utils.ts
+var import_jose = require("jose");
+function extractUserInfoFromToken(token) {
+  try {
+    const payload = (0, import_jose.decodeJwt)(token);
+    return {
+      id: payload.ulid,
+      email: payload.email,
+      phone: payload.phone,
+      username: payload.username,
+      firstName: payload.first_name,
+      lastName: payload.last_name,
+      storeId: payload.store_id,
+      isLoggedIn: payload.is_logged_in,
+      isAnonymous: !payload.is_logged_in,
+      customerId: payload.customer_id,
+      customerGroupId: payload.customer_group_id,
+      anonymousId: payload.anonymous_id,
+      tokenExpiry: new Date(payload.exp * 1e3),
+      tokenIssuedAt: new Date(payload.iat * 1e3)
+    };
+  } catch (error) {
+    console.warn("Failed to decode JWT token:", error);
+    return null;
+  }
+}
+function isTokenExpired(token, bufferSeconds = 30) {
+  try {
+    const payload = (0, import_jose.decodeJwt)(token);
+    if (!payload.exp) return true;
+    const currentTime = Math.floor(Date.now() / 1e3);
+    const expiryTime = payload.exp;
+    return currentTime >= expiryTime - bufferSeconds;
+  } catch (error) {
+    console.warn("Failed to decode JWT token:", error);
+    return true;
+  }
+}
+function getUserIdFromToken(token) {
+  const userInfo = extractUserInfoFromToken(token);
+  return userInfo?.id || null;
+}
+function isUserLoggedIn(token) {
+  const userInfo = extractUserInfoFromToken(token);
+  return userInfo?.isLoggedIn || false;
+}
+function isUserAnonymous(token) {
+  const userInfo = extractUserInfoFromToken(token);
+  return userInfo?.isAnonymous || true;
+}
+
+// src/lib/auth-utils.ts
+function getPathnameFromUrl(url) {
+  try {
+    const urlObj = new URL(url);
+    return urlObj.pathname;
+  } catch {
+    return url.split("?")[0];
+  }
+}
+function isAnonymousAuthEndpoint(pathname) {
+  return pathname.endsWith("/auth/anonymous");
+}
+function isTokenReturningEndpoint(pathname) {
+  const tokenEndpoints = [
+    "/auth/login/password",
+    "/auth/register/phone",
+    "/auth/register/email",
+    "/auth/verify-otp",
+    "/auth/refresh-token"
+  ];
+  return tokenEndpoints.some((endpoint) => pathname.endsWith(endpoint));
+}
+function isLogoutEndpoint(pathname) {
+  return pathname.endsWith("/auth/logout");
+}
+
+// src/lib/middleware.ts
+var MemoryTokenStorage = class {
+  accessToken = null;
+  refreshToken = null;
+  async getAccessToken() {
+    return this.accessToken;
+  }
+  async setAccessToken(token) {
+    this.accessToken = token;
+  }
+  async getRefreshToken() {
+    return this.refreshToken;
+  }
+  async setRefreshToken(token) {
+    this.refreshToken = token;
+  }
+  async clearTokens() {
+    this.accessToken = null;
+    this.refreshToken = null;
+  }
+};
+var BrowserTokenStorage = class {
+  accessTokenKey;
+  refreshTokenKey;
+  constructor(prefix = "storefront_") {
+    this.accessTokenKey = `${prefix}access_token`;
+    this.refreshTokenKey = `${prefix}refresh_token`;
+  }
+  async getAccessToken() {
+    if (typeof localStorage === "undefined") return null;
+    return localStorage.getItem(this.accessTokenKey);
+  }
+  async setAccessToken(token) {
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(this.accessTokenKey, token);
+    }
+  }
+  async getRefreshToken() {
+    if (typeof localStorage === "undefined") return null;
+    return localStorage.getItem(this.refreshTokenKey);
+  }
+  async setRefreshToken(token) {
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(this.refreshTokenKey, token);
+    }
+  }
+  async clearTokens() {
+    if (typeof localStorage !== "undefined") {
+      localStorage.removeItem(this.accessTokenKey);
+      localStorage.removeItem(this.refreshTokenKey);
+    }
+  }
+};
+var CookieTokenStorage = class {
+  accessTokenKey;
+  refreshTokenKey;
+  options;
+  constructor(options = {}) {
+    const prefix = options.prefix || "storefront_";
+    this.accessTokenKey = `${prefix}access_token`;
+    this.refreshTokenKey = `${prefix}refresh_token`;
+    this.options = {
+      maxAge: options.maxAge || 7 * 24 * 60 * 60,
+      // 7 days default
+      path: options.path || "/",
+      domain: options.domain,
+      secure: options.secure ?? (typeof window !== "undefined" && window.location?.protocol === "https:"),
+      sameSite: options.sameSite || "Lax",
+      httpOnly: false
+      // Must be false for client-side access
+    };
+  }
+  async getAccessToken() {
+    return this.getCookie(this.accessTokenKey);
+  }
+  async setAccessToken(token) {
+    this.setCookie(this.accessTokenKey, token);
+  }
+  async getRefreshToken() {
+    return this.getCookie(this.refreshTokenKey);
+  }
+  async setRefreshToken(token) {
+    this.setCookie(this.refreshTokenKey, token);
+  }
+  async clearTokens() {
+    this.deleteCookie(this.accessTokenKey);
+    this.deleteCookie(this.refreshTokenKey);
+  }
+  getCookie(name) {
+    if (typeof document === "undefined") return null;
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+      const cookieValue = parts.pop()?.split(";").shift();
+      return cookieValue ? decodeURIComponent(cookieValue) : null;
+    }
+    return null;
+  }
+  setCookie(name, value) {
+    if (typeof document === "undefined") return;
+    const encodedValue = encodeURIComponent(value);
+    let cookieString = `${name}=${encodedValue}`;
+    if (this.options.maxAge) {
+      cookieString += `; Max-Age=${this.options.maxAge}`;
+    }
+    if (this.options.path) {
+      cookieString += `; Path=${this.options.path}`;
+    }
+    if (this.options.domain) {
+      cookieString += `; Domain=${this.options.domain}`;
+    }
+    if (this.options.secure) {
+      cookieString += `; Secure`;
+    }
+    if (this.options.sameSite) {
+      cookieString += `; SameSite=${this.options.sameSite}`;
+    }
+    document.cookie = cookieString;
+  }
+  deleteCookie(name) {
+    if (typeof document === "undefined") return;
+    let cookieString = `${name}=; Max-Age=0`;
+    if (this.options.path) {
+      cookieString += `; Path=${this.options.path}`;
+    }
+    if (this.options.domain) {
+      cookieString += `; Domain=${this.options.domain}`;
+    }
+    document.cookie = cookieString;
+  }
+};
+function createAuthMiddleware(config) {
+  let isRefreshing = false;
+  let refreshPromise = null;
+  const refreshTokens = async () => {
+    if (isRefreshing && refreshPromise) {
+      return refreshPromise;
+    }
+    isRefreshing = true;
+    refreshPromise = (async () => {
+      try {
+        const refreshToken = await config.tokenStorage.getRefreshToken();
+        let newTokens;
+        if (refreshToken && !isTokenExpired(refreshToken)) {
+          if (config.refreshTokenFn) {
+            newTokens = await config.refreshTokenFn(refreshToken);
+          } else {
+            const response = await fetch(
+              `${config.baseUrl}/auth/refresh-token`,
+              {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json"
+                },
+                body: JSON.stringify({ refresh_token: refreshToken })
+              }
+            );
+            if (!response.ok) {
+              throw new Error(`Token refresh failed: ${response.status}`);
+            }
+            const data = await response.json();
+            newTokens = data.content;
+          }
+        } else {
+          const currentAccessToken = await config.tokenStorage.getAccessToken();
+          if (!currentAccessToken) {
+            throw new Error("No tokens available for refresh");
+          }
+          const reason = refreshToken ? "refresh token expired" : "no refresh token available";
+          const response = await fetch(`${config.baseUrl}/auth/anonymous`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...config.apiKey && { "X-Api-Key": config.apiKey },
+              Authorization: `Bearer ${currentAccessToken}`
+              // For user_id continuity
+            }
+          });
+          if (!response.ok) {
+            throw new Error(
+              `Anonymous token fallback failed: ${response.status}`
+            );
+          }
+          const data = await response.json();
+          newTokens = data.content;
+          console.info(
+            `Token refreshed via anonymous fallback (${reason}) - user may need to re-authenticate for privileged operations`
+          );
+        }
+        await config.tokenStorage.setAccessToken(newTokens.access_token);
+        await config.tokenStorage.setRefreshToken(newTokens.refresh_token);
+        config.onTokensUpdated?.(
+          newTokens.access_token,
+          newTokens.refresh_token
+        );
+      } catch (error) {
+        console.error("Token refresh failed:", error);
+        await config.tokenStorage.clearTokens();
+        config.onTokensCleared?.();
+        throw error;
+      } finally {
+        isRefreshing = false;
+        refreshPromise = null;
+      }
+    })();
+    return refreshPromise;
+  };
+  return {
+    async onRequest({ request }) {
+      const pathname = getPathnameFromUrl(request.url);
+      if (isAnonymousAuthEndpoint(pathname)) {
+        if (config.apiKey) {
+          request.headers.set("X-Api-Key", config.apiKey);
+        }
+        const existingToken = await config.tokenStorage.getAccessToken();
+        if (existingToken) {
+          request.headers.set("Authorization", `Bearer ${existingToken}`);
+        }
+        return request;
+      }
+      let accessToken = await config.tokenStorage.getAccessToken();
+      if (accessToken && isTokenExpired(accessToken)) {
+        try {
+          await refreshTokens();
+          accessToken = await config.tokenStorage.getAccessToken();
+        } catch (error) {
+        }
+      }
+      if (accessToken) {
+        request.headers.set("Authorization", `Bearer ${accessToken}`);
+      }
+      return request;
+    },
+    async onResponse({ request, response }) {
+      const pathname = getPathnameFromUrl(request.url);
+      if (response.ok) {
+        if (isTokenReturningEndpoint(pathname) || isAnonymousAuthEndpoint(pathname)) {
+          try {
+            const data = await response.clone().json();
+            const content = data.content;
+            if (content?.access_token && content?.refresh_token) {
+              await config.tokenStorage.setAccessToken(content.access_token);
+              await config.tokenStorage.setRefreshToken(content.refresh_token);
+              config.onTokensUpdated?.(
+                content.access_token,
+                content.refresh_token
+              );
+            }
+          } catch (error) {
+            console.warn("Failed to extract tokens from response:", error);
+          }
+        } else if (isLogoutEndpoint(pathname)) {
+          await config.tokenStorage.clearTokens();
+          config.onTokensCleared?.();
+        }
+      }
+      if (response.status === 401 && !isAnonymousAuthEndpoint(pathname)) {
+        const currentToken = await config.tokenStorage.getAccessToken();
+        if (currentToken && isTokenExpired(currentToken, 0)) {
+          try {
+            await refreshTokens();
+            const newToken = await config.tokenStorage.getAccessToken();
+            if (newToken) {
+              const retryRequest = request.clone();
+              retryRequest.headers.set("Authorization", `Bearer ${newToken}`);
+              return fetch(retryRequest);
+            }
+          } catch (error) {
+            console.warn("Token refresh failed on 401 response:", error);
+          }
+        }
+      }
+      return response;
+    }
+  };
+}
+function createDefaultAuthMiddleware(options) {
+  const tokenStorage = options.tokenStorage || (typeof localStorage !== "undefined" ? new BrowserTokenStorage() : new MemoryTokenStorage());
+  return createAuthMiddleware({
+    tokenStorage,
+    apiKey: options.apiKey,
+    baseUrl: options.baseUrl,
+    onTokensUpdated: options.onTokensUpdated,
+    onTokensCleared: options.onTokensCleared
+  });
+}
+
+// src/lib/logger-utils.ts
+var ResponseUtils = class {
+  /**
+   * Get response headers as a plain object
+   */
+  static getHeaders(response) {
+    return Object.fromEntries(response.headers.entries());
+  }
+  /**
+   * Get specific header value
+   */
+  static getHeader(response, name) {
+    return response.headers.get(name);
+  }
+  /**
+   * Check if response was successful
+   */
+  static isSuccess(response) {
+    return response.ok;
+  }
+  /**
+   * Get response metadata
+   */
+  static getMetadata(response) {
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      ok: response.ok,
+      url: response.url,
+      redirected: response.redirected,
+      type: response.type,
+      headers: Object.fromEntries(response.headers.entries())
+    };
+  }
+  /**
+   * Clone and read response as text (useful for debugging)
+   * Note: This can only be called once per response
+   */
+  static async getText(response) {
+    const cloned = response.clone();
+    return await cloned.text();
+  }
+  /**
+   * Clone and read response as JSON (useful for debugging)
+   * Note: This can only be called once per response
+   */
+  static async getJSON(response) {
+    const cloned = response.clone();
+    return await cloned.json();
+  }
+  /**
+   * Format response information for debugging
+   */
+  static format(response) {
+    const metadata = this.getMetadata(response);
+    return `${metadata.status} ${metadata.statusText} - ${metadata.url}`;
+  }
+};
+var DebugLogger = class {
+  logger;
+  responseTextCache = /* @__PURE__ */ new Map();
+  constructor(logger) {
+    this.logger = logger || ((level, message, data) => {
+      console.log(`[${level.toUpperCase()}]`, message);
+      if (data) console.log(data);
+    });
+  }
+  /**
+   * Log debug information about API request
+   */
+  logRequest(request, requestBody) {
+    this.logger("info", "API Request Debug Info", {
+      method: request.method,
+      url: request.url,
+      headers: Object.fromEntries(request.headers.entries()),
+      body: requestBody,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Log debug information about API response
+   */
+  async logResponse(response, responseBody) {
+    if (responseBody && typeof responseBody === "string") {
+      this.responseTextCache.set(response.url, responseBody);
+    }
+    this.logger("info", "API Response Debug Info", {
+      url: response.url,
+      status: response.status,
+      statusText: response.statusText,
+      ok: response.ok,
+      headers: Object.fromEntries(response.headers.entries()),
+      redirected: response.redirected,
+      type: response.type,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (responseBody) {
+      this.logger("info", "API Response Data", {
+        data: responseBody,
+        contentType: response.headers.get("content-type"),
+        contentLength: response.headers.get("content-length")
+      });
+    }
+  }
+  /**
+   * Log error information
+   */
+  logError(message, error) {
+    this.logger("error", message, error);
+  }
+  /**
+   * Get cached response text for a URL (if available)
+   */
+  getCachedResponseText(url) {
+    return this.responseTextCache.get(url) || null;
+  }
+  /**
+   * Clear cached response texts
+   */
+  clearCache() {
+    this.responseTextCache.clear();
+  }
+};
+async function extractRequestBody(request) {
+  if (request.method === "GET" || request.method === "HEAD") {
+    return null;
+  }
+  try {
+    const clonedRequest = request.clone();
+    const contentType = request.headers.get("content-type")?.toLowerCase();
+    if (contentType?.startsWith("application/json")) {
+      return await clonedRequest.json();
+    } else if (contentType?.startsWith("multipart/form-data")) {
+      return "[FormData - cannot display]";
+    } else if (contentType?.startsWith("text/")) {
+      return await clonedRequest.text();
+    }
+    return "[Request body - unknown format]";
+  } catch (error) {
+    return "[Request body unavailable]";
+  }
+}
+function createDebugMiddleware(logger) {
+  const debugLogger = new DebugLogger(logger);
+  return {
+    async onRequest({ request }) {
+      const requestBody = await extractRequestBody(request);
+      debugLogger.logRequest(request, requestBody);
+      return request;
+    },
+    async onResponse({ response }) {
+      const cloned = response.clone();
+      let responseBody = null;
+      try {
+        const contentType = response.headers.get("content-type")?.toLowerCase();
+        if (contentType?.startsWith("application/json")) {
+          responseBody = await cloned.json();
+        } else if (contentType?.startsWith("text/")) {
+          responseBody = await cloned.text();
+        }
+      } catch (error) {
+      }
+      await debugLogger.logResponse(response, responseBody);
+      return response;
+    },
+    async onError({ error, request }) {
+      debugLogger.logError("API Request Failed", {
+        error: {
+          name: error instanceof Error ? error.name : "Unknown",
+          message: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        },
+        request: {
+          method: request.method,
+          url: request.url,
+          headers: Object.fromEntries(request.headers.entries())
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      throw error;
+    }
+  };
+}
+
+// src/lib/header-utils.ts
+var HEADER_TRANSFORMATIONS = {
+  customer_group_id: "x-customer-group-id"
+  // Future transformations can be added here:
+  // some_param: "X-Some-Header",
+  // another_param: "X-Another-Header",
+};
+function transformHeaders(headers) {
+  const transformed = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value !== void 0) {
+      const headerName = HEADER_TRANSFORMATIONS[key] || key;
+      transformed[headerName] = value;
+    }
+  }
+  return transformed;
+}
+function mergeHeaders(defaultHeaders, methodHeaders) {
+  const merged = {};
+  if (defaultHeaders) {
+    const transformedDefaults = transformHeaders(defaultHeaders);
+    Object.assign(merged, transformedDefaults);
+  }
+  if (methodHeaders) {
+    Object.assign(merged, methodHeaders);
+  }
+  Object.keys(merged).forEach((key) => {
+    if (merged[key] === void 0) {
+      delete merged[key];
+    }
+  });
+  return merged;
+}
+
+// src/lib/client.ts
+var Environment = /* @__PURE__ */ ((Environment2) => {
+  Environment2["Staging"] = "staging";
+  Environment2["Production"] = "production";
+  return Environment2;
+})(Environment || {});
+var StorefrontAPIClient = class {
+  client;
+  config;
+  baseUrl;
+  initializationPromise = null;
+  /**
+   * Create a new StorefrontAPIClient
+   *
+   * @param config - Configuration for the API client
+   */
+  constructor(config) {
+    this.config = { ...config };
+    this.baseUrl = this.getBaseUrlFromConfig(this.config);
+    this.client = (0, import_openapi_fetch.default)({
+      baseUrl: this.baseUrl
+    });
+    if (this.config.tokenStorage) {
+      const authMiddleware = createDefaultAuthMiddleware({
+        apiKey: this.config.apiKey,
+        baseUrl: this.baseUrl,
+        tokenStorage: this.config.tokenStorage,
+        onTokensUpdated: this.config.onTokensUpdated,
+        onTokensCleared: this.config.onTokensCleared
+      });
+      this.client.use(authMiddleware);
+      if (this.config.accessToken) {
+        this.initializationPromise = this.initializeTokens(
+          this.config.accessToken,
+          this.config.refreshToken
+        );
+        this.config.accessToken = void 0;
+        this.config.refreshToken = void 0;
+      }
+    } else {
+      this.client.use({
+        onRequest: async ({ request }) => {
+          const pathname = getPathnameFromUrl(request.url);
+          if (isAnonymousAuthEndpoint(pathname)) {
+            if (this.config.apiKey) {
+              request.headers.set("X-Api-Key", this.config.apiKey);
+            }
+            if (this.config.accessToken) {
+              request.headers.set(
+                "Authorization",
+                `Bearer ${this.config.accessToken}`
+              );
+            }
+            return request;
+          }
+          if (this.config.accessToken) {
+            request.headers.set(
+              "Authorization",
+              `Bearer ${this.config.accessToken}`
+            );
+          }
+          return request;
+        }
+      });
+    }
+    if (this.config.timeout) {
+      this.setupTimeoutMiddleware();
+    }
+    if (this.config.debug) {
+      const debugMiddleware = createDebugMiddleware(this.config.logger);
+      this.client.use(debugMiddleware);
+    }
+  }
+  /**
+   * Set up timeout middleware
+   */
+  setupTimeoutMiddleware() {
+    this.client.use({
+      onRequest: async ({ request }) => {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(
+          () => controller.abort(),
+          this.config.timeout
+        );
+        if (request.signal) {
+          request.signal.addEventListener("abort", () => controller.abort());
+        }
+        const newRequest = new Request(request, {
+          signal: controller.signal
+        });
+        controller.signal.addEventListener(
+          "abort",
+          () => clearTimeout(timeoutId)
+        );
+        return newRequest;
+      }
+    });
+  }
+  /**
+   * Constructs the base URL from the configuration
+   *
+   * @param config - The client configuration
+   * @returns The constructed base URL
+   */
+  getBaseUrlFromConfig(config) {
+    if (config.baseUrl) {
+      return config.baseUrl;
+    }
+    const env = config.environment || "production" /* Production */;
+    switch (env) {
+      case "staging" /* Staging */:
+        return `https://staging.api.commercengine.io/api/v1/${config.storeId}/storefront`;
+      case "production" /* Production */:
+      default:
+        return `https://prod.api.commercengine.io/api/v1/${config.storeId}/storefront`;
+    }
+  }
+  /**
+   * Get the base URL of the API
+   *
+   * @returns The base URL of the API
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Get the authorization header value
+   * If using token storage, gets the current token from storage
+   * Otherwise returns the manual token
+   *
+   * @returns The Authorization header value or empty string if no token is set
+   */
+  async getAuthorizationHeader() {
+    if (this.config.tokenStorage && this.initializationPromise) {
+      await this.initializationPromise;
+    }
+    if (this.config.tokenStorage) {
+      const token = await this.config.tokenStorage.getAccessToken();
+      return token ? `Bearer ${token}` : "";
+    }
+    return this.config.accessToken ? `Bearer ${this.config.accessToken}` : "";
+  }
+  /**
+   * Set authentication tokens
+   *
+   * @param accessToken - The access token (required)
+   * @param refreshToken - The refresh token (optional)
+   *
+   * Behavior:
+   * - If tokenStorage is provided: Stores tokens for automatic management
+   * - If tokenStorage is not provided: Only stores access token for manual management
+   */
+  async setTokens(accessToken, refreshToken) {
+    if (this.config.tokenStorage) {
+      await this.config.tokenStorage.setAccessToken(accessToken);
+      if (refreshToken) {
+        await this.config.tokenStorage.setRefreshToken(refreshToken);
+      }
+    } else {
+      this.config.accessToken = accessToken;
+      if (refreshToken) {
+        console.warn(
+          "Refresh token provided but ignored in manual token management mode. Use tokenStorage for automatic management."
+        );
+      }
+    }
+  }
+  /**
+   * Clear all authentication tokens
+   *
+   * Behavior:
+   * - If tokenStorage is provided: Clears both access and refresh tokens from storage
+   * - If tokenStorage is not provided: Clears the manual access token
+   */
+  async clearTokens() {
+    if (this.config.tokenStorage) {
+      await this.config.tokenStorage.clearTokens();
+    } else {
+      this.config.accessToken = void 0;
+    }
+  }
+  /**
+   * Set the X-Api-Key header
+   *
+   * @param apiKey - The API key to set
+   */
+  setApiKey(apiKey) {
+    this.config.apiKey = apiKey;
+  }
+  /**
+   * Clear the X-Api-Key header
+   */
+  clearApiKey() {
+    this.config.apiKey = void 0;
+  }
+  /**
+   * Execute a request and handle the response
+   *
+   * @param apiCall - Function that executes the API request
+   * @returns Promise with the API response
+   */
+  async executeRequest(apiCall) {
+    try {
+      const { data, error, response } = await apiCall();
+      if (error) {
+        return {
+          data: null,
+          error,
+          response
+        };
+      }
+      if (data && data.content !== void 0) {
+        return {
+          data: data.content,
+          error: null,
+          response
+        };
+      }
+      return {
+        data,
+        error: null,
+        response
+      };
+    } catch (err) {
+      const mockResponse = new Response(null, {
+        status: 0,
+        statusText: "Network Error"
+      });
+      const errorResult = {
+        data: null,
+        error: {
+          success: false,
+          code: "NETWORK_ERROR",
+          message: "Network error occurred",
+          error: err
+        },
+        response: mockResponse
+      };
+      return errorResult;
+    }
+  }
+  /**
+   * Initialize tokens in storage (private helper method)
+   */
+  async initializeTokens(accessToken, refreshToken) {
+    try {
+      if (this.config.tokenStorage) {
+        await this.config.tokenStorage.setAccessToken(accessToken);
+        if (refreshToken) {
+          await this.config.tokenStorage.setRefreshToken(refreshToken);
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to initialize tokens in storage:", error);
+    }
+  }
+  /**
+   * Merge default headers with method-level headers
+   * Method-level headers take precedence over default headers
+   *
+   * @param methodHeaders - Headers passed to the specific method call
+   * @returns Merged headers object with proper HTTP header names
+   */
+  mergeHeaders(methodHeaders) {
+    return mergeHeaders(this.config.defaultHeaders, methodHeaders);
+  }
+};
+
+// src/lib/catalog.ts
+var CatalogClient = class extends StorefrontAPIClient {
+  /**
+   * List all products
+   *
+   * @param options - Optional query parameters
+   * @param headers - Optional header parameters (customer_group_id, etc.)
+   * @returns Promise with products and pagination info
+   */
+  async listProducts(options, headers) {
+    const mergedHeaders = this.mergeHeaders(headers);
+    return this.executeRequest(
+      () => this.client.GET("/catalog/products", {
+        params: {
+          query: options,
+          header: mergedHeaders
+        }
+      })
+    );
+  }
+  /**
+   * List all skus
+   *
+   * @param options - Optional query parameters
+   * @param headers - Optional header parameters (customer_group_id, etc.)
+   * @returns Promise with skus and pagination info
+   */
+  async listSkus(options, headers) {
+    const mergedHeaders = this.mergeHeaders(headers);
+    return this.executeRequest(
+      () => this.client.GET("/catalog/skus", {
+        params: {
+          query: options,
+          header: mergedHeaders
+        }
+      })
+    );
+  }
+  /**
+   * Get details for a specific product
+   *
+   * @param pathParams - The path parameters (product ID or slug)
+   * @param headers - Optional header parameters (customer_group_id, etc.)
+   * @returns Promise with product details
+   */
+  async getProductDetail(pathParams, headers) {
+    const mergedHeaders = this.mergeHeaders(headers);
+    return this.executeRequest(
+      () => this.client.GET("/catalog/products/{product_id_or_slug}", {
+        params: {
+          path: pathParams,
+          header: mergedHeaders
+        }
+      })
+    );
+  }
+  /**
+   * List variants for a specific product
+   *
+   * @param pathParams - The path parameters (product ID)
+   * @param headers - Optional header parameters (customer_group_id, etc.)
+   * @returns Promise with variants
+   */
+  async listProductVariants(pathParams, headers) {
+    const mergedHeaders = this.mergeHeaders(headers);
+    return this.executeRequest(
+      () => this.client.GET("/catalog/products/{product_id}/variants", {
+        params: {
+          path: pathParams,
+          header: mergedHeaders
+        }
+      })
+    );
+  }
+  /**
+   * Get details for a specific variant
+   *
+   * @param pathParams - The path parameters (product ID and variant ID)
+   * @param headers - Optional header parameters (customer_group_id, etc.)
+   * @returns Promise with variant details
+   */
+  async getVariantDetail(pathParams, headers) {
+    const mergedHeaders = this.mergeHeaders(headers);
+    return this.executeRequest(
+      () => this.client.GET("/catalog/products/{product_id}/variants/{variant_id}", {
+        params: {
+          path: pathParams,
+          header: mergedHeaders
+        }
+      })
+    );
+  }
+  /**
+   * List all categories
+   *
+   * @param options - Optional query parameters
+   * @returns Promise with categories and pagination info
+   */
+  async listCategories(options) {
+    return this.executeRequest(
+      () => this.client.GET("/catalog/categories", {
+        params: { query: options }
+      })
+    );
+  }
+  /**
+   * List reviews for a specific product
+   *
+   * @param pathParams - The path parameters (product ID)
+   * @param queryParams - Optional query parameters
+   * @returns Promise with reviews and pagination info
+   */
+  async listProductReviews(pathParams, queryParams) {
+    return this.executeRequest(
+      () => this.client.GET("/catalog/products/{product_id}/reviews", {
+        params: {
+          path: pathParams,
+          query: queryParams
+        }
+      })
+    );
+  }
+  /**
+   * Create a review for a specific product
+   *
+   * @param pathParams - The path parameters (product ID)
+   * @param formData - The review data
+   * @returns Promise that resolves when the review is created
+   */
+  async createProductReview(pathParams, formData) {
+    return this.executeRequest(
+      () => this.client.POST("/catalog/products/{product_id}/reviews", {
+        params: {
+          path: pathParams
+        },
+        body: formData,
+        bodySerializer: (body) => {
+          const fd = new FormData();
+          for (const [key, value] of Object.entries(body)) {
+            if (value !== void 0 && value !== null) {
+              if (value instanceof File || value instanceof Blob) {
+                fd.append(key, value);
+              } else {
+                fd.append(key, String(value));
+              }
+            }
+          }
+          return fd;
+        }
+      })
+    );
+  }
+  /**
+   * Search for products
+   *
+   * @param searchData - The search parameters
+   * @returns Promise with search results, facet distribution, facet stats, and pagination
+   */
+  async searchProducts(searchData, headers) {
+    const mergedHeaders = this.mergeHeaders(headers);
+    return this.executeRequest(
+      () => this.client.POST("/catalog/products/search", {
+        body: searchData,
+        header: mergedHeaders
+      })
+    );
+  }
+  /**
+   * List cross-sell products
+   *
+   * @param options - Optional query parameters
+   * @param headers - Optional header parameters (customer_group_id, etc.)
+   * @returns Promise with cross-sell products
+   */
+  async listCrossSellProducts(options, headers) {
+    const mergedHeaders = this.mergeHeaders(headers);
+    return this.executeRequest(
+      () => this.client.GET("/catalog/products/cross-sell", {
+        params: {
+          query: options,
+          header: mergedHeaders
+        }
+      })
+    );
+  }
+  /**
+   * List up-sell products
+   *
+   * @param options - Optional query parameters
+   * @param headers - Optional header parameters (customer_group_id, etc.)
+   * @returns Promise with up-sell products
+   */
+  async listUpSellProducts(options, headers) {
+    const mergedHeaders = this.mergeHeaders(headers);
+    return this.executeRequest(
+      () => this.client.GET("/catalog/products/up-sell", {
+        params: {
+          query: options,
+          header: mergedHeaders
+        }
+      })
+    );
+  }
+  /**
+   * List similar products
+   *
+   * @param options - Optional query parameters
+   * @param headers - Optional header parameters (customer_group_id, etc.)
+   * @returns Promise with similar products
+   */
+  async listSimilarProducts(options, headers) {
+    const mergedHeaders = this.mergeHeaders(headers);
+    return this.executeRequest(
+      () => this.client.GET("/catalog/products/similar", {
+        params: {
+          query: options,
+          header: mergedHeaders
+        }
+      })
+    );
+  }
+};
+
+// src/lib/cart.ts
+var CartClient = class extends StorefrontAPIClient {
+  /**
+   * Create a new cart
+   *
+   * @param payload - Object containing the items to add to the cart
+   * @returns Promise with the created cart
+   */
+  async createCart(payload) {
+    return this.executeRequest(
+      () => this.client.POST("/carts", {
+        body: payload
+      })
+    );
+  }
+  /**
+   * Get cart details - either by ID or using the stored cart ID
+   *
+   * @param cartId - The ID of the cart
+   * @returns Promise with cart details
+   */
+  async getCart(cartId) {
+    return this.executeRequest(
+      () => this.client.GET("/carts/{id}", {
+        params: {
+          path: cartId
+        }
+      })
+    );
+  }
+  /**
+   * Delete a cart - either by ID or using the stored cart ID
+   *
+   * @param cartId - The ID of the cart
+   * @returns Promise that resolves when the cart is deleted
+   */
+  async deleteCart(cartId) {
+    return this.executeRequest(
+      () => this.client.DELETE("/carts/{id}", {
+        params: {
+          path: cartId
+        }
+      })
+    );
+  }
+  /**
+   * Update cart items (add, update quantity, remove)
+   *
+   * @param cartId - The cart id
+   * @param body - The body of the request
+   * @returns Promise with updated cart
+   */
+  async addDeleteCartItem(cartId, body) {
+    return this.executeRequest(
+      () => this.client.POST("/carts/{id}/items", {
+        params: {
+          path: cartId
+        },
+        body
+      })
+    );
+  }
+  /**
+   * Get cart details by user ID
+   *
+   * @param userId - The ID of the user
+   * @returns Promise with cart details
+   */
+  async getUserCart(userId) {
+    return this.executeRequest(
+      () => this.client.GET("/carts/users/{user_id}", {
+        params: {
+          path: userId
+        }
+      })
+    );
+  }
+  /**
+   * Delete a cart by user ID
+   *
+   * @param userId - The ID of the user
+   * @returns Promise that resolves when the cart is deleted
+   */
+  async deleteUserCart(userId) {
+    return this.executeRequest(
+      () => this.client.DELETE("/carts/users/{user_id}", {
+        params: {
+          path: userId
+        },
+        body: void 0
+      })
+    );
+  }
+  /**
+   * Update cart addresses
+   *
+   * @param cartId - The ID of the cart
+   * @param addressData - The address data
+   * @returns Promise with updated cart
+   */
+  async updateCartAddress(cartId, addressData) {
+    return this.executeRequest(
+      () => this.client.POST("/carts/{id}/address", {
+        params: {
+          path: cartId
+        },
+        body: addressData
+      })
+    );
+  }
+  /**
+   * Apply a coupon to the cart
+   *
+   * @param cartId - The ID of the cart
+   * @param couponCode - The coupon code
+   * @returns Promise with updated cart
+   */
+  async applyCoupon(cartId, couponCode) {
+    return this.executeRequest(
+      () => this.client.POST("/carts/{id}/coupon", {
+        params: {
+          path: cartId
+        },
+        body: couponCode
+      })
+    );
+  }
+  /**
+   * Remove a coupon from the cart
+   *
+   * @param cartId - The ID of the cart
+   * @returns Promise with updated cart
+   */
+  async removeCoupon(cartId) {
+    return this.executeRequest(
+      () => this.client.DELETE("/carts/{id}/coupon", {
+        params: {
+          path: cartId
+        },
+        body: void 0
+      })
+    );
+  }
+  /**
+   * Redeem loyalty points
+   *
+   * @param cartId - The ID of the cart
+   * @param points - The number of points to redeem
+   * @returns Promise with updated cart
+   */
+  async redeemLoyaltyPoints(cartId, points) {
+    return this.executeRequest(
+      () => this.client.POST("/carts/{id}/loyalty-points", {
+        params: {
+          path: cartId
+        },
+        body: points
+      })
+    );
+  }
+  /**
+   * Remove loyalty points
+   *
+   * @param cartId - The ID of the cart
+   * @returns Promise with updated cart
+   */
+  async removeLoyaltyPoints(cartId) {
+    return this.executeRequest(
+      () => this.client.DELETE("/carts/{id}/loyalty-points", {
+        params: {
+          path: cartId
+        },
+        body: void 0
+      })
+    );
+  }
+  /**
+   * Update shipping method
+   *
+   * @param cartId - The ID of the cart
+   * @param body - The body of the request
+   * @returns Promise with updated cart
+   */
+  async updateShippingMethod(cartId, body) {
+    return this.executeRequest(
+      () => this.client.POST("/carts/{id}/shipping-method", {
+        params: {
+          path: cartId
+        },
+        body
+      })
+    );
+  }
+  /**
+   * Use credit balance
+   *
+   * @param cartId - The ID of the cart
+   * @param body - The body of the request
+   * @returns Promise with updated cart
+   */
+  async redeemCreditBalance(cartId, body) {
+    return this.executeRequest(
+      () => this.client.POST("/carts/{id}/credit-balance", {
+        params: {
+          path: cartId
+        },
+        body
+      })
+    );
+  }
+  /**
+   * Remove credit balance
+   *
+   * @param cartId - The ID of the cart
+   * @returns Promise with updated cart
+   */
+  async removeCreditBalance(cartId) {
+    return this.executeRequest(
+      () => this.client.DELETE("/carts/{id}/credit-balance", {
+        params: {
+          path: cartId
+        },
+        body: void 0
+      })
+    );
+  }
+  /**
+   * Redeem gift card
+   *
+   * @param cartId - The ID of the cart
+   * @param body - The body of the request
+   * @returns Promise with updated cart
+   */
+  async redeemGiftCard(cartId, body) {
+    return this.executeRequest(
+      () => this.client.POST("/carts/{id}/gift-card", {
+        params: {
+          path: cartId
+        },
+        body
+      })
+    );
+  }
+  /**
+   * Remove gift card
+   *
+   * @param cartId - The ID of the cart
+   * @returns Promise with updated cart
+   */
+  async removeGiftCard(cartId) {
+    return this.executeRequest(
+      () => this.client.DELETE("/carts/{id}/gift-card", {
+        params: {
+          path: cartId
+        },
+        body: void 0
+      })
+    );
+  }
+  /**
+   * Get wishlist items
+   *
+   * @param userId - The ID of the user
+   * @returns Promise with wishlist items
+   */
+  async getWishlist(userId) {
+    return this.executeRequest(
+      () => this.client.GET("/wishlist/{user_id}", {
+        params: {
+          path: userId
+        }
+      })
+    );
+  }
+  /**
+   * Add item to wishlist
+   *
+   * @param userId - The ID of the user
+   * @param itemId - The ID of the item
+   * @returns Promise with updated wishlist
+   */
+  async addToWishlist(userId, itemId) {
+    return this.executeRequest(
+      () => this.client.POST("/wishlist/{user_id}", {
+        params: {
+          path: userId
+        },
+        body: itemId
+      })
+    );
+  }
+  /**
+   * Remove item from wishlist
+   *
+   * @param userId - The ID of the user
+   * @param itemId - The ID of the item
+   * @returns Promise with updated wishlist
+   */
+  async removeFromWishlist(userId, body) {
+    return this.executeRequest(
+      () => this.client.DELETE("/wishlist/{user_id}", {
+        params: {
+          path: userId
+        },
+        body
+      })
+    );
+  }
+  /**
+   * Get all available coupons
+   *
+   * @param headers - Optional header parameters (customer_group_id, etc.)
+   * @returns Promise with all available coupons
+   */
+  async getAvailableCoupons(headers) {
+    const mergedHeaders = this.mergeHeaders(headers);
+    return this.executeRequest(
+      () => this.client.GET("/carts/available-coupons", {
+        params: {
+          header: mergedHeaders
+        }
+      })
+    );
+  }
+  /**
+   * Get all available promotions
+   *
+   * @param headers - Optional header parameters (customer_group_id, etc.)
+   * @returns Promise with all available promotions
+   */
+  async getAvailablePromotions(headers) {
+    const mergedHeaders = this.mergeHeaders(headers);
+    return this.executeRequest(
+      () => this.client.GET("/carts/available-promotions", {
+        params: {
+          header: mergedHeaders
+        }
+      })
+    );
+  }
+};
+
+// src/lib/auth.ts
+var AuthClient = class extends StorefrontAPIClient {
+  /**
+   * Get anonymous token for guest users
+   */
+  async getAnonymousToken() {
+    return this.executeRequest(
+      () => this.client.POST("/auth/anonymous")
+    );
+  }
+  /**
+   * Login with phone number
+   *
+   * @param phoneNumber - Phone number (without country code)
+   * @param countryCode - Country code (defaults to +91)
+   * @param registerIfNotExists - Whether to register if user doesn't exist
+   * @returns Promise with OTP token and action 
+   */
+  async loginWithPhone(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/login/phone", {
+        body
+      })
+    );
+  }
+  /**
+   * Login with WhatsApp
+   *
+   * @param phoneNumber - Phone number (without country code)
+   * @param countryCode - Country code (defaults to +91)
+   * @param registerIfNotExists - Whether to register if user doesn't exist
+   * @returns Promise with OTP token and action
+   */
+  async loginWithWhatsApp(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/login/whatsapp", {
+        body
+      })
+    );
+  }
+  /**
+   * Login with email
+   *
+   * @param email - Email address
+   * @param registerIfNotExists - Whether to register if user doesn't exist
+   * @returns Promise with OTP token and action
+   */
+  async loginWithEmail(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/login/email", {
+        body
+      })
+    );
+  }
+  /**
+   * Login with password
+   *
+   * @param credentials - Login credentials
+   * @returns Promise with user info and tokens
+   */
+  async loginWithPassword(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/login/password", {
+        body
+      })
+    );
+  }
+  /**
+   * Forgot password
+   *
+   * @param email - Email address
+   * @returns Promise with user info and tokens
+   */
+  async forgotPassword(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/forgot-password", {
+        body
+      })
+    );
+  }
+  /**
+   * Reset password
+   *
+   * @param email - Email address
+   * @returns Promise with user info and tokens
+   */
+  async resetPassword(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/reset-password", {
+        body
+      })
+    );
+  }
+  /**
+   * Change password
+   *
+   * @param oldPassword - Old password
+   * @param newPassword - New password
+   * @param newPasswordConfirmation - New password confirmation
+   * @returns Promise with new access token and refresh token
+   */
+  async changePassword(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/change-password", {
+        body
+      })
+    );
+  }
+  /**
+   * Verify OTP
+   *
+   * @param otp - One-time password
+   * @param otpToken - OTP token from login request
+   * @param otpAction - OTP action from login request
+   * @returns Promise with user info and tokens
+   */
+  async verifyOtp(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/verify-otp", {
+        body
+      })
+    );
+  }
+  /**
+   * Register with phone
+   *
+   * @param options - Registration details
+   * @returns Promise with user info and tokens
+   */
+  async registerWithPhone(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/register/phone", {
+        body
+      })
+    );
+  }
+  /**
+   * Register with email
+   *
+   * @param options - Registration details
+   * @returns Promise with user info and tokens
+   */
+  async registerWithEmail(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/register/email", {
+        body
+      })
+    );
+  }
+  /**
+   * Refresh the access token using a refresh token
+   * @param refreshToken - The refresh token to use for refreshing the access token
+   * @returns Promise with the new access token and refresh token
+   */
+  async refreshToken(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/refresh-token", {
+        body
+      })
+    );
+  }
+  /**
+   * Logout
+   *
+   * @returns Promise that resolves when logout is complete
+   */
+  async logout() {
+    return this.executeRequest(
+      () => this.client.POST("/auth/logout")
+    );
+  }
+  /**
+   * Get user details
+   *
+   * @param userId - User ID
+   * @returns Promise with user details
+   */
+  async getUserDetails(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/auth/user/{id}", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * Update user details
+   *
+   * @param userId - User ID
+   * @returns Promise with user details
+   */
+  async updateUserDetails(pathParams, body) {
+    return this.executeRequest(
+      () => this.client.PUT("/auth/user/{id}", {
+        params: {
+          path: pathParams
+        },
+        body
+      })
+    );
+  }
+  /**
+   * Add profile image
+   *
+   * @param userId - User ID
+   * @returns Promise with user details
+   */
+  async addProfileImage(pathParams, formData) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/user/{id}/profile-image", {
+        params: {
+          path: pathParams
+        },
+        body: formData,
+        bodySerializer: (body) => {
+          const fd = new FormData();
+          for (const [key, value] of Object.entries(body)) {
+            if (value !== void 0 && value !== null) {
+              fd.append(key, value);
+            }
+          }
+          return fd;
+        }
+      })
+    );
+  }
+  /**
+   * Update profile image
+   *
+   * @param userId - User ID
+   * @returns Promise with user details
+   */
+  async updateProfileImage(pathParams, formData) {
+    return this.executeRequest(
+      () => this.client.PUT("/auth/user/{id}/profile-image", {
+        params: {
+          path: pathParams
+        },
+        body: formData,
+        bodySerializer: (body) => {
+          const fd = new FormData();
+          for (const [key, value] of Object.entries(body)) {
+            if (value !== void 0 && value !== null) {
+              fd.append(key, value);
+            }
+          }
+          return fd;
+        }
+      })
+    );
+  }
+  /**
+   * Delete profile image
+   *
+   * @param userId - User ID
+   * @returns Promise with user details
+   */
+  async deleteProfileImage(pathParams) {
+    return this.executeRequest(
+      () => this.client.DELETE("/auth/user/{id}/profile-image", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * Get profile image
+   *
+   * @param userId - User ID
+   * @returns Promise with user details
+   */
+  async getProfileImage(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/auth/user/{id}/profile-image", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * Deactivate user account
+   *
+   * @param userId - User ID
+   * @returns Promise with user details
+   */
+  async deactivateUserAccount(pathParams) {
+    return this.executeRequest(
+      () => this.client.PUT("/auth/user/{id}/deactivate", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * Get user notification preferences
+   *
+   * @param userId - User ID
+   * @returns Promise with user details
+   */
+  async getUserNotificationPreferences(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/auth/user/{id}/notification-preferences", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * Update user notification preferences
+   *
+   * @param userId - User ID
+   * @returns Promise with user details
+   */
+  async updateUserNotificationPreferences(pathParams, body) {
+    return this.executeRequest(
+      () => this.client.PUT("/auth/user/{id}/notification-preferences", {
+        params: {
+          path: pathParams
+        },
+        body
+      })
+    );
+  }
+  /**
+   * Create user notification preference
+   *
+   * @param userId - User ID
+   * @returns Promise with user details
+   */
+  async createUserNotificationPreference(pathParams, body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/user/{id}/notification-preferences", {
+        params: {
+          path: pathParams
+        },
+        body
+      })
+    );
+  }
+  /**
+   * Generate OTP
+   * 
+   * @param body - OTP generation body
+   * @returns Promise with OTP generation response
+   */
+  async generateOtp(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/generate-otp", {
+        body
+      })
+    );
+  }
+  /**
+   * Check whether email or phone is already verified
+   *
+   * @param body - OTP generation body
+   * @returns Promise with OTP generation response
+   */
+  async checkEmailOrPhoneIsVerified(body) {
+    return this.executeRequest(
+      () => this.client.POST("/auth/verified-email-phone", {
+        body
+      })
+    );
+  }
+};
+
+// src/lib/order.ts
+var OrderClient = class extends StorefrontAPIClient {
+  /**
+   * Get order details
+   *
+   * @param orderNumber - Order number
+   * @returns Promise with order details
+   */
+  async getOrderDetails(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/orders/{order_number}", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * Create order
+   *
+   * @param cartId - Cart ID
+   * @param paymentGateway - Payment gateway
+   * @param paymentGatewayParams - Params for the selected payment gateway
+   * @returns Promise with order details
+   */
+  async createOrder(body) {
+    return this.executeRequest(
+      () => this.client.POST("/orders", {
+        body
+      })
+    );
+  }
+  /**
+   * List all orders
+   *
+   * @param queryParams - Query parameters
+   * @returns Promise with order details
+   */
+  async listOrders(queryParams) {
+    return this.executeRequest(
+      () => this.client.GET("/orders", {
+        params: {
+          query: queryParams
+        }
+      })
+    );
+  }
+  /**
+   * Get payment status for an order
+   *
+   * @param orderNumber - Order number
+   * @returns Promise with payment status
+   */
+  async getPaymentStatus(orderNumber) {
+    return this.executeRequest(
+      () => this.client.GET("/orders/{order_number}/payment-status", {
+        params: {
+          path: { order_number: orderNumber }
+        }
+      })
+    );
+  }
+  /**
+   * Get all shipments for an order
+   *
+   * @param orderNumber - Order number
+   * @returns Promise with shipments
+   */
+  async listOrderShipments(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/orders/{order_number}/shipments", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * List order payments
+   *
+   * @param orderNumber - Order number
+   * @returns Promise with payments
+   */
+  async listOrderPayments(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/orders/{order_number}/payments", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * List order refunds
+   *
+   * @param orderNumber - Order number
+   * @returns Promise with refunds
+   */
+  async listOrderRefunds(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/orders/{order_number}/refunds", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * Cancel an order
+   *
+   * @param orderNumber - Order number
+   * @returns Promise with order details
+   */
+  async cancelOrder(pathParams, body) {
+    return this.executeRequest(
+      () => this.client.POST("/orders/{order_number}/cancel", {
+        params: {
+          path: pathParams
+        },
+        body
+      })
+    );
+  }
+  /**
+   * Retry payment for an order
+   *
+   * @param orderNumber - Order number
+   * @returns Promise with order details
+   */
+  async retryOrderPayment(pathParams, body) {
+    return this.executeRequest(
+      () => this.client.POST("/orders/{order_number}/retry-payment", {
+        params: {
+          path: pathParams
+        },
+        body
+      })
+    );
+  }
+};
+
+// src/lib/shipping.ts
+var ShippingClient = class extends StorefrontAPIClient {
+  /**
+   * Get shipping options for an order
+   *
+   * @param body - Shipping methods body
+   * @returns Promise with shipping options
+   */
+  async getShippingMethods(body) {
+    return this.executeRequest(
+      () => this.client.POST("/shipping/shipping-methods", {
+        body
+      })
+    );
+  }
+  /**
+   * Check pincode deliverability
+   *
+   * @param pathParams - Path parameters
+   * @returns Promise with pincode deliverability result
+   */
+  async checkPincodeDeliverability(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/shipping/serviceability/{pincode}", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+};
+
+// src/lib/helper.ts
+var HelpersClient = class extends StorefrontAPIClient {
+  /**
+   * Get a list of countries
+   *
+   * @returns Promise with countries
+   */
+  async listCountries() {
+    return this.executeRequest(
+      () => this.client.GET("/common/countries", {})
+    );
+  }
+  /**
+   * - Get a list of states for a country
+   *
+   * @param pathParams - Path parameters
+   * @returns Promise with states
+   */
+  async listCountryStates(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/common/countries/{country_iso_code}/states", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * Get pincodes for a country
+   *
+   * @param pathParams - Path parameters
+   * @returns Promise with pincodes
+   */
+  async listCountryPincodes(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/common/countries/{country_iso_code}/pincodes", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+};
+
+// src/lib/customer.ts
+var CustomerClient = class extends StorefrontAPIClient {
+  /**
+   * Create a customer
+   *
+   * @param body - Customer creation body
+   * @returns Promise with customer details
+   */
+  async createCustomer(body) {
+    return this.executeRequest(
+      () => this.client.POST("/customers", {
+        body
+      })
+    );
+  }
+  /**
+   * Get customer details
+   *
+   * @param pathParams - Path parameters
+   * @returns Promise with customer details
+   */
+  async getCustomer(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/customers/{id}", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * Update a customer
+   *
+   * @param pathParams - Path parameters
+   * @param body - Customer update body
+   * @returns Promise with customer details
+   */
+  async updateCustomer(pathParams, body) {
+    return this.executeRequest(
+      () => this.client.PUT("/customers/{id}", {
+        params: {
+          path: pathParams
+        },
+        body
+      })
+    );
+  }
+  /**
+   * Get all saved addresses for a customer
+   *
+   * @param pathParams - Path parameters
+   * @returns Promise with addresses
+   */
+  async listAddresses(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/customers/{user_id}/addresses", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * Create a new address for a customer
+   *
+   * @param pathParams - Path parameters
+   * @param body - Address creation body
+   * @returns Promise with address details
+   */
+  async createAddress(pathParams, body) {
+    return this.executeRequest(
+      () => this.client.POST("/customers/{user_id}/addresses", {
+        params: {
+          path: pathParams
+        },
+        body
+      })
+    );
+  }
+  /**
+   * Get an address for a customer
+   *
+   * @param pathParams - Path parameters
+   * @returns Promise with address details
+   */
+  async getAddress(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/customers/{user_id}/addresses/{address_id}", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * Update an address for a customer
+   *
+   * @param pathParams - Path parameters
+   * @param body - Address update body
+   * @returns Promise with address details
+   */
+  async updateAddress(pathParams, body) {
+    return this.executeRequest(
+      () => this.client.PUT("/customers/{user_id}/addresses/{address_id}", {
+        params: {
+          path: pathParams
+        },
+        body
+      })
+    );
+  }
+  /**
+   * Delete an address for a customer
+   *
+   * @param pathParams - Path parameters
+   * @returns Promise with address details
+   */
+  async deleteAddress(pathParams) {
+    return this.executeRequest(
+      () => this.client.DELETE("/customers/{user_id}/addresses/{address_id}", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * Get customer loyalty details
+   *
+   * @param pathParams - Path parameters
+   * @returns Promise with loyalty details
+   */
+  async getLoyaltyDetails(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/customers/{user_id}/loyalty", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * List all loyalty points activity for a customer
+   *
+   * @param pathParams - Path parameters
+   * @returns Promise with loyalty points activity
+   */
+  async listLoyaltyPointsActivity(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/customers/{user_id}/loyalty-points-activity", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+  /**
+   * List all reviews left by a customer
+   *
+   * @param pathParams - Path parameters
+   * @returns Promise with reviews
+   */
+  async listCustomerReviews(pathParams) {
+    return this.executeRequest(
+      () => this.client.GET("/customers/{user_id}/reviews", {
+        params: {
+          path: pathParams
+        }
+      })
+    );
+  }
+};
+
+// src/index.ts
+var StorefrontSDK = class {
+  /**
+   * Client for catalog-related endpoints (products, categories, etc.)
+   */
+  catalog;
+  /**
+   * Client for cart-related endpoints
+   */
+  cart;
+  /**
+   * Client for authentication-related endpoints
+   */
+  auth;
+  /**
+   * Client for customer-related endpoints
+   */
+  customer;
+  /**
+   * Client for helper-related endpoints
+   */
+  helpers;
+  /**
+   * Client for shipping-related endpoints
+   */
+  shipping;
+  /**
+   * Client for order-related endpoints
+   */
+  order;
+  /**
+   * Create a new StorefrontSDK instance
+   *
+   * @param options - Configuration options for the SDK
+   */
+  constructor(options) {
+    const config = {
+      storeId: options.storeId,
+      environment: options.environment,
+      baseUrl: options.baseUrl,
+      accessToken: options.accessToken,
+      refreshToken: options.refreshToken,
+      apiKey: options.apiKey,
+      timeout: options.timeout,
+      tokenStorage: options.tokenStorage,
+      onTokensUpdated: options.onTokensUpdated,
+      onTokensCleared: options.onTokensCleared,
+      defaultHeaders: options.defaultHeaders,
+      debug: options.debug,
+      logger: options.logger
+    };
+    this.catalog = new CatalogClient(config);
+    this.cart = new CartClient(config);
+    this.auth = new AuthClient(config);
+    this.customer = new CustomerClient(config);
+    this.helpers = new HelpersClient(config);
+    this.shipping = new ShippingClient(config);
+    this.order = new OrderClient(config);
+  }
+  /**
+   * Set authentication tokens for all clients
+   *
+   * @param accessToken - The access token (required)
+   * @param refreshToken - The refresh token (optional)
+   *
+   * Behavior:
+   * - If tokenStorage is provided: Stores tokens for automatic management
+   * - If tokenStorage is not provided: Only stores access token for manual management
+   */
+  async setTokens(accessToken, refreshToken) {
+    await this.catalog.setTokens(accessToken, refreshToken);
+    await this.cart.setTokens(accessToken, refreshToken);
+    await this.auth.setTokens(accessToken, refreshToken);
+    await this.customer.setTokens(accessToken, refreshToken);
+    await this.helpers.setTokens(accessToken, refreshToken);
+    await this.shipping.setTokens(accessToken, refreshToken);
+    await this.order.setTokens(accessToken, refreshToken);
+  }
+  /**
+   * Clear all authentication tokens from all clients
+   *
+   * Behavior:
+   * - If tokenStorage is provided: Clears both access and refresh tokens from storage
+   * - If tokenStorage is not provided: Clears the manual access token
+   */
+  async clearTokens() {
+    await this.catalog.clearTokens();
+    await this.cart.clearTokens();
+    await this.auth.clearTokens();
+    await this.customer.clearTokens();
+    await this.helpers.clearTokens();
+    await this.shipping.clearTokens();
+    await this.order.clearTokens();
+  }
+  /**
+   * Set the API key for all clients
+   *
+   * @param apiKey - The API key to set
+   */
+  setApiKey(apiKey) {
+    this.catalog.setApiKey(apiKey);
+    this.cart.setApiKey(apiKey);
+    this.auth.setApiKey(apiKey);
+    this.customer.setApiKey(apiKey);
+    this.helpers.setApiKey(apiKey);
+    this.shipping.setApiKey(apiKey);
+    this.order.setApiKey(apiKey);
+  }
+  /**
+   * Clear the API key from all clients
+   */
+  clearApiKey() {
+    this.catalog.clearApiKey();
+    this.cart.clearApiKey();
+    this.auth.clearApiKey();
+    this.customer.clearApiKey();
+    this.helpers.clearApiKey();
+    this.shipping.clearApiKey();
+    this.order.clearApiKey();
+  }
+  /**
+   * Get the current access token if using token storage
+   */
+  async getAccessToken() {
+    return await this.auth.getAuthorizationHeader().then(
+      (header) => header.startsWith("Bearer ") ? header.substring(7) : null
+    );
+  }
+  /**
+   * Get user information from the current access token
+   *
+   * @returns User information extracted from JWT token, or null if no token or invalid token
+   */
+  async getUserInfo() {
+    const token = await this.getAccessToken();
+    if (!token) return null;
+    return extractUserInfoFromToken(token);
+  }
+  /**
+   * Get the current user ID from the access token
+   *
+   * @returns User ID (ulid) or null if no token or invalid token
+   */
+  async getUserId() {
+    const token = await this.getAccessToken();
+    if (!token) return null;
+    return getUserIdFromToken(token);
+  }
+  /**
+   * Check if the current user is logged in (not anonymous)
+   *
+   * @returns True if user is logged in, false if anonymous or no token
+   */
+  async isLoggedIn() {
+    const token = await this.getAccessToken();
+    if (!token) return false;
+    return isUserLoggedIn(token);
+  }
+  /**
+   * Check if the current user is anonymous
+   *
+   * @returns True if user is anonymous or no token, false if logged in
+   */
+  async isAnonymous() {
+    const token = await this.getAccessToken();
+    if (!token) return true;
+    return isUserAnonymous(token);
+  }
+  /**
+   * Get the customer ID from the current access token
+   *
+   * @returns Customer ID or null if no token, invalid token, or user has no customer ID
+   */
+  async getCustomerId() {
+    const userInfo = await this.getUserInfo();
+    return userInfo?.customerId || null;
+  }
+  /**
+   * Get the customer group ID from the current access token
+   *
+   * @returns Customer group ID or null if no token, invalid token, or user has no customer group
+   */
+  async getCustomerGroupId() {
+    const userInfo = await this.getUserInfo();
+    return userInfo?.customerGroupId || null;
+  }
+  /**
+   * Set default headers for all clients
+   *
+   * @param headers - Default headers to set (only supported headers allowed)
+   */
+  setDefaultHeaders(headers) {
+    const newConfig = { ...this.catalog["config"], defaultHeaders: headers };
+    this.catalog["config"] = newConfig;
+    this.cart["config"] = newConfig;
+    this.auth["config"] = newConfig;
+    this.customer["config"] = newConfig;
+    this.helpers["config"] = newConfig;
+    this.shipping["config"] = newConfig;
+    this.order["config"] = newConfig;
+  }
+  /**
+   * Get current default headers
+   *
+   * @returns Current default headers
+   */
+  getDefaultHeaders() {
+    return this.catalog["config"].defaultHeaders;
+  }
+};
+var index_default = StorefrontSDK;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthClient,
+  BrowserTokenStorage,
+  CartClient,
+  CatalogClient,
+  CookieTokenStorage,
+  CustomerClient,
+  Environment,
+  HelpersClient,
+  MemoryTokenStorage,
+  OrderClient,
+  ResponseUtils,
+  ShippingClient,
+  StorefrontAPIClient,
+  StorefrontSDK
+});
+//# sourceMappingURL=index.cjs.map