@commercengine/storefront-sdk 0.8.0 → 0.8.2

package/dist/index.cjs

@@ -1,4311 +0,0 @@
-"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,
-  StoreConfigClient: () => StoreConfigClient,
-  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;
-  let hasAssessedTokens = false;
-  const assessTokenStateOnce = async () => {
-    if (hasAssessedTokens) return;
-    hasAssessedTokens = true;
-    try {
-      const accessToken = await config.tokenStorage.getAccessToken();
-      const refreshToken = await config.tokenStorage.getRefreshToken();
-      if (!accessToken && refreshToken) {
-        await config.tokenStorage.clearTokens();
-        console.info("Cleaned up orphaned refresh token");
-      }
-    } catch (error) {
-      console.warn("Token state assessment failed:", error);
-    }
-  };
-  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);
-      await assessTokenStateOnce();
-      if (isAnonymousAuthEndpoint(pathname)) {
-        if (config.apiKey) {
-          request.headers.set("X-Api-Key", config.apiKey);
-        }
-        const existingToken = await config.tokenStorage.getAccessToken();
-        if (existingToken && !isTokenExpired(existingToken) && isUserLoggedIn(existingToken)) {
-          return new Response(
-            JSON.stringify({
-              message: "Cannot create anonymous session while authenticated",
-              success: false,
-              code: "USER_ALREADY_AUTHENTICATED"
-            }),
-            {
-              status: 400,
-              headers: { "Content-Type": "application/json" }
-            }
-          );
-        }
-        if (existingToken) {
-          request.headers.set("Authorization", `Bearer ${existingToken}`);
-        }
-        return request;
-      }
-      let accessToken = await config.tokenStorage.getAccessToken();
-      if (!accessToken) {
-        try {
-          const response = await fetch(`${config.baseUrl}/auth/anonymous`, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              ...config.apiKey && { "X-Api-Key": config.apiKey }
-            }
-          });
-          if (response.ok) {
-            const data = await response.json();
-            const tokens = data.content;
-            if (tokens?.access_token && tokens?.refresh_token) {
-              await config.tokenStorage.setAccessToken(tokens.access_token);
-              await config.tokenStorage.setRefreshToken(tokens.refresh_token);
-              accessToken = tokens.access_token;
-              config.onTokensUpdated?.(tokens.access_token, tokens.refresh_token);
-              console.info("Automatically created anonymous session for first API request");
-            }
-          }
-        } catch (error) {
-          console.warn("Failed to automatically create anonymous tokens:", error);
-        }
-      }
-      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
-   *
-   * @example
-   * ```typescript
-   * // Basic product listing
-   * const { data, error } = await sdk.catalog.listProducts();
-   *
-   * if (error) {
-   *   console.error("Failed to list products:", error);
-   *   return;
-   * }
-   *
-   * console.log("Products found:", data.products?.length || 0);
-   * console.log("Pagination:", data.pagination);
-   *
-   * // With filtering and pagination
-   * const { data: filteredData, error: filteredError } = await sdk.catalog.listProducts({
-   *   page: 1,
-   *   limit: 20,
-   *   sort_by: JSON.stringify({ "created_at": "desc" }),
-   *   category_slug: ["electronics", "smartphones"]
-   * });
-   *
-   * // Override customer group ID for this specific request
-   * const { data: overrideData, error: overrideError } = await sdk.catalog.listProducts(
-   *   {
-   *     page: 1,
-   *     limit: 20,
-   *     sort_by: JSON.stringify({ "created_at": "desc" }),
-   *     category_slug: ["electronics", "smartphones"]
-   *   },
-   *   {
-   *     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
-   *   }
-   * );
-   *
-   * if (filteredError) {
-   *   console.error("Failed to get filtered products:", filteredError);
-   *   return;
-   * }
-   *
-   * filteredData.products?.forEach(product => {
-   *   console.log(`Product: ${product.name} - ${product.price}`);
-   * });
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * // Basic SKU listing
-   * const { data, error } = await sdk.catalog.listSkus();
-   *
-   * if (error) {
-   *   console.error("Failed to list SKUs:", error);
-   *   return;
-   * }
-   *
-   * console.log("SKUs found:", data.skus?.length || 0);
-   * console.log("Pagination:", data.pagination);
-   *
-   * // With pagination
-   * const { data: skuData, error: skuError } = await sdk.catalog.listSkus({
-   *   page: 1,
-   *   limit: 50
-   * });
-   *
-   * // Override customer group ID for this specific request
-   * const { data: overrideData, error: overrideError } = await sdk.catalog.listSkus(
-   *   {
-   *     page: 1,
-   *     limit: 50
-   *   },
-   *   {
-   *     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
-   *   }
-   * );
-   *
-   * if (skuError) {
-   *   console.error("Failed to get SKUs:", skuError);
-   *   return;
-   * }
-   *
-   * skuData.skus?.forEach(sku => {
-   *   console.log(`SKU: ${sku.sku} - Price: ${sku.price}`);
-   * });
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * // Get product by ID
-   * const { data, error } = await sdk.catalog.getProductDetail(
-   *   { product_id_or_slug: "prod_123" }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to get product details:", error);
-   *   return;
-   * }
-   *
-   * console.log("Product:", data.product.name);
-   * console.log("Price:", data.product.price);
-   * console.log("Description:", data.product.description);
-   *
-   * // Get product by slug
-   * const { data: slugData, error: slugError } = await sdk.catalog.getProductDetail({
-   *   product_id_or_slug: "detox-candy"
-   * });
-   *
-   * // Override customer group ID for this specific request
-   * const { data: overrideData, error: overrideError } = await sdk.catalog.getProductDetail(
-   *   { product_id_or_slug: "detox-candy" },
-   *   {
-   *     "x-customer-group-id": "premium_customers" // Override default SDK config
-   *   }
-   * );
-   *
-   * if (slugError) {
-   *   console.error("Failed to get product by slug:", slugError);
-   *   return;
-   * }
-   *
-   * console.log("Product with custom pricing:", slugData.product.price);
-   * ```
-   */
-  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 all variants for a specific product
-   *
-   * @param pathParams - The path parameters (product ID)
-   * @param headers - Optional header parameters (customer_group_id, etc.)
-   * @returns Promise with product variants and pagination info
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.catalog.listProductVariants(
-   *   { product_id: "prod_123" }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to list product variants:", error);
-   *   return;
-   * }
-   *
-   * console.log("Variants found:", data.variants?.length || 0);
-   *
-   * data.variants?.forEach(variant => {
-   *   console.log(`Variant: ${variant.name} - SKU: ${variant.sku} - Price: ${variant.price}`);
-   * });
-   *
-   * // Override customer group ID for this specific request
-   * const { data: overrideData, error: overrideError } = await sdk.catalog.listProductVariants(
-   *   { product_id: "prod_123" },
-   *   {
-   *     "x-customer-group-id": "wholesale_customers" // Override default SDK config
-   *   }
-   * );
-   * ```
-   */
-  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 product 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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.catalog.getVariantDetail(
-   *   {
-   *     product_id: "prod_123",
-   *     variant_id: "var_456"
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to get variant details:", error);
-   *   return;
-   * }
-   *
-   * console.log("Variant:", data.variant.name);
-   * console.log("SKU:", data.variant.sku);
-   * console.log("Price:", data.variant.price);
-   * console.log("Stock:", data.variant.stock);
-   * ```
-   */
-  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 product categories
-   *
-   * @param options - Optional query parameters
-   * @returns Promise with categories and pagination info
-   *
-   * @example
-   * ```typescript
-   * // Basic category listing
-   * const { data, error } = await sdk.catalog.listCategories();
-   *
-   * if (error) {
-   *   console.error("Failed to list categories:", error);
-   *   return;
-   * }
-   *
-   * console.log("Categories found:", data.categories?.length || 0);
-   *
-   * data.categories?.forEach(category => {
-   *   console.log(`Category: ${category.name} - ${category.description}`);
-   * });
-   *
-   * // With pagination
-   * const { data: catData, error: catError } = await sdk.catalog.listCategories({
-   *   page: 1,
-   *   limit: 10
-   * });
-   * ```
-   */
-  async listCategories(options) {
-    return this.executeRequest(
-      () => this.client.GET("/catalog/categories", {
-        params: {
-          query: options
-        }
-      })
-    );
-  }
-  /**
-   * List all reviews for a specific product
-   *
-   * @param pathParams - The path parameters (product ID)
-   * @param queryParams - Optional query parameters
-   * @returns Promise with product reviews and pagination info
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.catalog.listProductReviews(
-   *   { product_id: "prod_123" }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to list product reviews:", error);
-   *   return;
-   * }
-   *
-   * console.log("Reviews found:", data.reviews?.length || 0);
-   *
-   * data.reviews?.forEach(review => {
-   *   console.log(`Review by ${review.customer_name}: ${review.rating}/5`);
-   *   console.log("Comment:", review.comment);
-   * });
-   *
-   * // With pagination
-   * const { data: reviewData, error: reviewError } = await sdk.catalog.listProductReviews(
-   *   { product_id: "prod_123" },
-   *   {
-   *     page: 1,
-   *     limit: 5
-   *   }
-   * );
-   * ```
-   */
-  async listProductReviews(pathParams, queryParams) {
-    return this.executeRequest(
-      () => this.client.GET("/catalog/products/{product_id}/reviews", {
-        params: {
-          path: pathParams,
-          query: queryParams
-        }
-      })
-    );
-  }
-  /**
-   * Create a product review
-   *
-   * @param pathParams - The path parameters (product ID)
-   * @param formData - The review data including rating, comment, and optional images
-   * @returns Promise with review creation response
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.catalog.createProductReview(
-   *   { product_id: "prod_123" },
-   *   {
-   *     rating: 5,
-   *     comment: "Excellent product! Highly recommended.",
-   *     images: [
-   *       new File(["image data"], "review1.jpg", { type: "image/jpeg" }),
-   *       new File(["image data"], "review2.jpg", { type: "image/jpeg" })
-   *     ]
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to create review:", error);
-   *   return;
-   * }
-   *
-   * console.log("Review created successfully:", data.message);
-   * ```
-   */
-  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 query and filters
-   * @param headers - Optional header parameters (customer_group_id, etc.)
-   * @returns Promise with search results including products, facets, and pagination
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.catalog.searchProducts({
-   *   query: "smartphone",
-   *   filters: {
-   *     category: ["electronics", "mobile"],
-   *     price_range: { min: 100, max: 1000 },
-   *     brand: ["Apple", "Samsung"] // facet names depend on product configuration
-   *   },
-   *   page: 1,
-   *   limit: 20
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to search products:", error);
-   *   return;
-   * }
-   *
-   * console.log("Search results:", data.skus?.length || 0, "products found");
-   * console.log("Facet distribution:", data.facet_distribution);
-   * console.log("Price range:", data.facet_stats.price_range);
-   *
-   * data.skus?.forEach(sku => {
-   *   console.log(`Found: ${sku.name} - ${sku.price}`);
-   * });
-   *
-   * // Override customer group ID for this specific request
-   * const { data: overrideData, error: overrideError } = await sdk.catalog.searchProducts(
-   *   {
-   *     query: "laptop",
-   *     filters: { category: ["computers"] }
-   *   },
-   *   {
-   *     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
-   *   }
-   * );
-   * ```
-   */
-  async searchProducts(searchData, headers) {
-    const mergedHeaders = this.mergeHeaders(headers);
-    return this.executeRequest(
-      () => this.client.POST("/catalog/products/search", {
-        params: {
-          header: mergedHeaders
-        },
-        body: searchData
-      })
-    );
-  }
-  /**
-   * List cross-sell products
-   *
-   * @param options - Optional query parameters for filtering and pagination
-   * @param headers - Optional header parameters (customer_group_id, etc.)
-   * @returns Promise with cross-sell products
-   * @example
-   * ```typescript
-   * // Basic usage - get cross-sell products for cart items
-   * const { data, error } = await sdk.catalog.listCrossSellProducts({
-   *   product_id: ["prod_01H9XYZ12345ABCDE", "prod_01H9ABC67890FGHIJ"]
-   * });
-   *
-   * // Advanced usage with pagination and custom sorting
-   * const { data, error } = await sdk.catalog.listCrossSellProducts({
-   *   product_id: ["prod_01H9XYZ12345ABCDE"],
-   *   page: 1,
-   *   limit: 10,
-   *   sort_by: '{"price":"asc"}'
-   * });
-   *
-   * // Override customer group ID for this specific request
-   * const { data, error } = await sdk.catalog.listCrossSellProducts(
-   *   {
-   *     product_id: ["prod_01H9XYZ12345ABCDE"],
-   *     page: 1,
-   *     limit: 10
-   *   },
-   *   {
-   *     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to get cross-sell products:", error.message);
-   * } else {
-   *   console.log("Cross-sell products found:", data.content.products.length);
-   *   console.log("Pagination:", data.content.pagination);
-   *
-   *   data.content.products.forEach(product => {
-   *     console.log(`Product: ${product.name} - ${product.price}`);
-   *   });
-   * }
-   * ```
-   */
-  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 for filtering and pagination
-   * @param headers - Optional header parameters (customer_group_id, etc.)
-   * @returns Promise with up-sell products
-   * @example
-   * ```typescript
-   * // Basic usage - get up-sell products for cart items
-   * const { data, error } = await sdk.catalog.listUpSellProducts({
-   *   product_id: ["prod_01H9XYZ12345ABCDE"]
-   * });
-   *
-   * // Advanced usage with pagination and custom sorting
-   * const { data, error } = await sdk.catalog.listUpSellProducts({
-   *   product_id: ["prod_01H9XYZ12345ABCDE"],
-   *   page: 1,
-   *   limit: 15,
-   *   sort_by: '{"relevance":"desc"}'
-   * });
-   *
-   * // Override customer group ID for this specific request
-   * const { data, error } = await sdk.catalog.listUpSellProducts(
-   *   {
-   *     product_id: ["prod_01H9XYZ12345ABCDE"],
-   *     page: 1,
-   *     limit: 15
-   *   },
-   *   {
-   *     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to get up-sell products:", error.message);
-   * } else {
-   *   console.log("Up-sell products found:", data.content.products.length);
-   *   console.log("Pagination:", data.content.pagination);
-   *
-   *   data.content.products.forEach(product => {
-   *     console.log(`Up-sell: ${product.name} - ${product.price}`);
-   *   });
-   * }
-   * ```
-   */
-  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 for filtering and pagination
-   * @param headers - Optional header parameters (customer_group_id, etc.)
-   * @returns Promise with similar products
-   * @example
-   * ```typescript
-   * // Basic usage - get similar products for a specific product
-   * const { data, error } = await sdk.catalog.listSimilarProducts({
-   *   product_id: ["prod_01H9XYZ12345ABCDE"]
-   * });
-   *
-   * // Advanced usage with pagination and custom sorting
-   * const { data, error } = await sdk.catalog.listSimilarProducts({
-   *   product_id: ["prod_01H9XYZ12345ABCDE"],
-   *   page: 1,
-   *   limit: 20,
-   *     sort_by: '{"relevance":"desc"}'
-   * });
-   *
-   * // Override customer group ID for this specific request
-   * const { data, error } = await sdk.catalog.listSimilarProducts(
-   *   {
-   *     product_id: ["prod_01H9XYZ12345ABCDE"],
-   *     page: 1,
-   *     limit: 20
-   *   },
-   *   {
-   *     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to get similar products:", error.message);
-   * } else {
-   *   console.log("Similar products found:", data.content.products.length);
-   *   console.log("Pagination:", data.content.pagination);
-   *
-   *   data.content.products.forEach(product => {
-   *     console.log(`Similar: ${product.name} - ${product.price}`);
-   *   });
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.createCart({
-   *   items: [
-   *     {
-   *       product_id: "01H9XYZ12345ABCDE",
-   *       variant_id: null,
-   *       quantity: 2
-   *     },
-   *     {
-   *       product_id: "01H9ABC67890FGHIJ",
-   *       variant_id: "01H9XYZ67890KLMNO",
-   *       quantity: 1
-   *     }
-   *   ],
-   *   metadata: {
-   *     "source": "web",
-   *     "campaign": "summer_sale"
-   *   }
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to create cart:", error.message);
-   * } else {
-   *   console.log("Cart created:", data.cart.id);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.getCart({
-   *   id: "01H9CART12345ABCDE"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get cart:", error.message);
-   * } else {
-   *   const cart = data.cart;
-   *   console.log("Cart total:", cart.total_amount);
-   *   console.log("Items count:", cart.items.length);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.deleteCart({
-   *   id: "01H9CART12345ABCDE"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to delete cart:", error.message);
-   * } else {
-   *   console.log("Cart deleted:", data.message);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * // Add item to cart
-   * const { data, error } = await sdk.cart.addDeleteCartItem(
-   *   { id: "01H9CART12345ABCDE" },
-   *   {
-   *     product_id: "01H9XYZ12345ABCDE",
-   *     variant_id: null,
-   *     quantity: 3
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to update cart:", error.message);
-   * } else {
-   *   console.log("Cart updated:", data.cart.items.length);
-   * }
-   *
-   * // Remove item from cart (set quantity to 0)
-   * const { data: removeData, error: removeError } = await sdk.cart.addDeleteCartItem(
-   *   { id: "01H9CART12345ABCDE" },
-   *   {
-   *     product_id: "01H9XYZ12345ABCDE",
-   *     variant_id: null,
-   *     quantity: 0
-   *   }
-   * );
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.getUserCart({
-   *   user_id: "01H9USER12345ABCDE"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get user cart:", error.message);
-   * } else {
-   *   console.log("User cart ID:", data.cart.id);
-   *   console.log("Cart value:", data.cart.subtotal_amount);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.deleteUserCart({
-   *   user_id: "01H9USER12345ABCDE"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to delete user cart:", error.message);
-   * } else {
-   *   console.log("User cart cleared:", data.message);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * // For registered users with saved addresses
-   * const { data, error } = await sdk.cart.updateCartAddress(
-   *   { id: "01H9CART12345ABCDE" },
-   *   {
-   *     billing_address_id: "01H9ADDR12345BILL",
-   *     shipping_address_id: "01H9ADDR12345SHIP"
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to update cart address:", error.message);
-   * } else {
-   *   console.log("Addresses updated:", data.message);
-   * }
-   *
-   * // For guest checkout with new addresses
-   * const { data: guestData, error: guestError } = await sdk.cart.updateCartAddress(
-   *   { id: "01H9CART12345ABCDE" },
-   *   {
-   *     billing_address: {
-   *       first_name: "John",
-   *       last_name: "Doe",
-   *       email: "john@example.com",
-   *       phone: "9876543210",
-   *       country_code: "+91",
-   *       address_line1: "123 Main Street",
-   *       address_line2: "Apt 4B",
-   *       city: "Mumbai",
-   *       state: "Maharashtra",
-   *       pincode: "400001",
-   *       country: "India",
-   *       landmark: "Near Station",
-   *       tax_identification_number: null,
-   *       business_name: null
-   *     },
-   *     shipping_address: {
-   *       first_name: "John",
-   *       last_name: "Doe",
-   *       email: "john@example.com",
-   *       phone: "9876543210",
-   *       country_code: "+91",
-   *       address_line1: "456 Oak Avenue",
-   *       address_line2: null,
-   *       city: "Pune",
-   *       state: "Maharashtra",
-   *       pincode: "411001",
-   *       country: "India",
-   *       landmark: "Near Mall",
-   *       tax_identification_number: null,
-   *       business_name: null
-   *     }
-   *   }
-   * );
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.applyCoupon(
-   *   { id: "01H9CART12345ABCDE" },
-   *   { coupon_code: "FLAT100OFF" }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to apply coupon:", error.message);
-   * } else {
-   *   console.log("Coupon applied, new total:", data.cart.total_amount);
-   *   console.log("Discount amount:", data.cart.coupon_discount_amount);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.removeCoupon({
-   *   id: "01H9CART12345ABCDE"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to remove coupon:", error.message);
-   * } else {
-   *   console.log("Coupon removed, new total:", data.cart.total_amount);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.redeemLoyaltyPoints(
-   *   { id: "01H9CART12345ABCDE" },
-   *   { points: 500 }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to redeem loyalty points:", error.message);
-   * } else {
-   *   console.log("Points redeemed, new total:", data.cart.total_amount);
-   *   console.log("Points discount:", data.cart.loyalty_points_discount_amount);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.removeLoyaltyPoints({
-   *   id: "01H9CART12345ABCDE"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to remove loyalty points:", error.message);
-   * } else {
-   *   console.log("Loyalty points removed, new total:", data.cart.total_amount);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.updateShippingMethod(
-   *   { id: "01H9CART12345ABCDE" },
-   *   {
-   *     shipping_method_id: "01H9SHIP12345FAST",
-   *     estimated_delivery_date: "2024-01-15"
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to update shipping method:", error.message);
-   * } else {
-   *   console.log("Shipping method updated:", data.cart.shipping_method?.name);
-   *   console.log("Shipping cost:", data.cart.shipping_cost);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.redeemCreditBalance(
-   *   { id: "01H9CART12345ABCDE" },
-   *   { amount: 250.00 }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to redeem credit balance:", error.message);
-   * } else {
-   *   console.log("Credit applied, new total:", data.cart.total_amount);
-   *   console.log("Credit discount:", data.cart.credit_balance_discount_amount);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.removeCreditBalance({
-   *   id: "01H9CART12345ABCDE"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to remove credit balance:", error.message);
-   * } else {
-   *   console.log("Credit balance removed, new total:", data.cart.total_amount);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.redeemGiftCard(
-   *   { id: "01H9CART12345ABCDE" },
-   *   {
-   *     gift_card_code: "GIFT2024-ABCD-1234",
-   *     amount: 100.00
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to redeem gift card:", error.message);
-   * } else {
-   *   console.log("Gift card applied, new total:", data.cart.total_amount);
-   *   console.log("Gift card discount:", data.cart.gift_card_discount_amount);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.removeGiftCard({
-   *   id: "01H9CART12345ABCDE"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to remove gift card:", error.message);
-   * } else {
-   *   console.log("Gift card removed, new total:", data.cart.total_amount);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.getWishlist({
-   *   user_id: "01H9USER12345ABCDE"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get wishlist:", error.message);
-   * } else {
-   *   const products = data.products;
-   *   console.log("Wishlist items:", products.length);
-   *   products.forEach(product => {
-   *     console.log("Product:", product.name, "Price:", product.price);
-   *   });
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.addToWishlist(
-   *   { user_id: "01H9USER12345ABCDE" },
-   *   {
-   *     product_id: "01F3Z7KG06J4ACWH1C4926KJEC",
-   *     variant_id: null
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to add to wishlist:", error.message);
-   * } else {
-   *   const products = data.products;
-   *   console.log("Item added to wishlist, total items:", products.length);
-   * }
-   * ```
-   */
-  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 body - The body containing product details to remove
-   * @returns Promise with updated wishlist
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.removeFromWishlist(
-   *   { user_id: "01H9USER12345ABCDE" },
-   *   {
-   *     product_id: "01F3Z7KG06J4ACWH1C4926KJEC",
-   *     variant_id: null
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to remove from wishlist:", error.message);
-   * } else {
-   *   const products = data.products;
-   *   console.log("Item removed from wishlist, remaining items:", products.length);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * // Get all available coupons
-   * const { data, error } = await sdk.cart.getAvailableCoupons();
-   *
-   * if (error) {
-   *   console.error("Failed to get available coupons:", error.message);
-   * } else {
-   *   const coupons = data.coupons || [];
-   *   console.log("Available coupons:", coupons.length);
-   *   coupons.forEach(coupon => {
-   *     console.log("Coupon:", coupon.code, "Discount:", coupon.discount_amount);
-   *   });
-   * }
-   *
-   * // Override customer group ID for this specific request
-   * const { data: overrideData, error: overrideError } = await sdk.cart.getAvailableCoupons({
-   *   "x-customer-group-id": "01H9GROUP12345ABC" // Override default SDK config
-   * });
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * // Get all available promotions
-   * const { data, error } = await sdk.cart.getAvailablePromotions();
-   *
-   * if (error) {
-   *   console.error("Failed to get available promotions:", error.message);
-   * } else {
-   *   const promotions = data.promotions || [];
-   *   console.log("Available promotions:", promotions.length);
-   *   promotions.forEach(promotion => {
-   *     console.log("Promotion:", promotion.name, "Type:", promotion.promotion_type);
-   *   });
-   * }
-   *
-   * // Override customer group ID for this specific request
-   * const { data: overrideData, error: overrideError } = await sdk.cart.getAvailablePromotions({
-   *   "x-customer-group-id": "01H9GROUP12345ABC" // Override default SDK config
-   * });
-   * ```
-   */
-  async getAvailablePromotions(headers) {
-    const mergedHeaders = this.mergeHeaders(headers);
-    return this.executeRequest(
-      () => this.client.GET("/carts/available-promotions", {
-        params: {
-          header: mergedHeaders
-        }
-      })
-    );
-  }
-  /**
-   * Evaluate promotions
-   *
-   * @param cartId - The ID of the cart
-   * @returns Promise with evaluated promotions
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.evaluatePromotions({
-   *   id: "01H9CART12345ABCDE"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to evaluate promotions:", error.message);
-   * } else {
-   *   const applicable = data.applicable_promotions || [];
-   *   const inapplicable = data.inapplicable_promotions || [];
-   *
-   *   console.log("Applicable promotions:", applicable.length);
-   *   applicable.forEach(promo => {
-   *     console.log(`- ${promo.name}: ${promo.savings_message}`);
-   *   });
-   *
-   *   console.log("Inapplicable promotions:", inapplicable.length);
-   *   inapplicable.forEach(promo => {
-   *     console.log(`- ${promo.name}: ${promo.reason}`);
-   *   });
-   * }
-   * ```
-   */
-  async evaluatePromotions(cartId) {
-    return this.executeRequest(
-      () => this.client.GET("/carts/{id}/evaluate-promotions", {
-        params: {
-          path: cartId
-        }
-      })
-    );
-  }
-  /**
-   * Evaluate coupons
-   *
-   * @param cartId - The ID of the cart
-   * @returns Promise with evaluated coupons
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.cart.evaluateCoupons({
-   *   id: "01H9CART12345ABCDE"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to evaluate coupons:", error.message);
-   * } else {
-   *   const applicable = data.applicable_coupons || [];
-   *   const inapplicable = data.inapplicable_coupons || [];
-   *
-   *   console.log("Applicable coupons:", applicable.length);
-   *   applicable.forEach(coupon => {
-   *     console.log(`- ${coupon.code}: Save $${coupon.estimated_discount}`);
-   *   });
-   *
-   *   console.log("Inapplicable coupons:", inapplicable.length);
-   *   inapplicable.forEach(coupon => {
-   *     console.log(`- ${coupon.code}: ${coupon.reason}`);
-   *   });
-   * }
-   * ```
-   */
-  async evaluateCoupons(cartId) {
-    return this.executeRequest(
-      () => this.client.GET("/carts/{id}/evaluate-coupons", {
-        params: {
-          path: cartId
-        }
-      })
-    );
-  }
-};
-
-// src/lib/auth.ts
-var AuthClient = class extends StorefrontAPIClient {
-  /**
-   * Get anonymous token for guest users
-   *
-   * @example
-   * ```typescript
-   * // Get token for guest browsing
-   * const { data, error } = await sdk.auth.getAnonymousToken();
-   *
-   * if (error) {
-   *   console.error("Failed to get anonymous token:", error.message);
-   * } else {
-   *   console.log("Anonymous token:", data.access_token);
-   *   // Store token or proceed with guest operations
-   * }
-   * ```
-   */
-  async getAnonymousToken() {
-    return this.executeRequest(() => this.client.POST("/auth/anonymous"));
-  }
-  /**
-   * Login with phone number
-   *
-   * @param body - Login request body containing phone number and options
-   * @returns Promise with OTP token and action
-   * @example
-   * ```typescript
-   * // Login with phone number
-   * const { data, error } = await sdk.auth.loginWithPhone({
-   *   phoneNumber: "9876543210",
-   *   countryCode: "+91",
-   *   registerIfNotExists: true
-   * });
-   *
-   * if (error) {
-   *   console.error("Login failed:", error.message);
-   * } else {
-   *   console.log("OTP sent. Token:", data.otpToken);
-   *   console.log("Action:", data.action); // "login" or "register"
-   *   // Redirect user to OTP verification screen
-   * }
-   * ```
-   */
-  async loginWithPhone(body) {
-    return this.executeRequest(
-      () => this.client.POST("/auth/login/phone", {
-        body
-      })
-    );
-  }
-  /**
-   * Login with WhatsApp
-   *
-   * @param body - Login request body containing phone number and options
-   * @returns Promise with OTP token and action
-   * @example
-   * ```typescript
-   * // Login with WhatsApp number
-   * const { data, error } = await sdk.auth.loginWithWhatsApp({
-   *   phone: "9876543210",
-   *   country_code: "+91",
-   *   register_if_not_exists: true
-   * });
-   *
-   * if (error) {
-   *   console.error("WhatsApp login failed:", error.message);
-   * } else {
-   *   console.log("OTP sent to WhatsApp. Token:", data.otp_token);
-   *   console.log("Action:", data.otp_action); // "login" or "register"
-   * }
-   * ```
-   */
-  async loginWithWhatsApp(body) {
-    return this.executeRequest(
-      () => this.client.POST("/auth/login/whatsapp", {
-        body
-      })
-    );
-  }
-  /**
-   * Login with email
-   *
-   * @param body - Login request body containing email and options
-   * @returns Promise with OTP token and action
-   * @example
-   * ```typescript
-   * // Login with email address
-   * const { data, error } = await sdk.auth.loginWithEmail({
-   *   email: "customer@example.com",
-   *   registerIfNotExists: true
-   * });
-   *
-   * if (error) {
-   *   console.error("Email login failed:", error.message);
-   * } else {
-   *   console.log("OTP sent to email. Token:", data.otpToken);
-   *   console.log("Action:", data.action); // "login" or "register"
-   *   // Show OTP input form
-   * }
-   * ```
-   */
-  async loginWithEmail(body) {
-    return this.executeRequest(
-      () => this.client.POST("/auth/login/email", {
-        body
-      })
-    );
-  }
-  /**
-   * Login with password
-   *
-   * @param body - Login credentials containing email/phone and password
-   * @returns Promise with user info and tokens
-   * @example
-   * ```typescript
-   * // Login with email and password
-   * const { data, error } = await sdk.auth.loginWithPassword({
-   *   email: "customer@example.com",
-   *   password: "securePassword123"
-   * });
-   *
-   * if (error) {
-   *   console.error("Password login failed:", error.message);
-   * } else {
-   *   console.log("Login successful:", data.user.email);
-   *   console.log("Access token:", data.access_token);
-   * }
-   * ```
-   */
-  async loginWithPassword(body) {
-    return this.executeRequest(
-      () => this.client.POST("/auth/login/password", {
-        body
-      })
-    );
-  }
-  /**
-   * Forgot password
-   *
-   * @param body - Request body containing email address
-   * @returns Promise with password reset information
-   * @example
-   * ```typescript
-   * // Send password reset email
-   * const { data, error } = await sdk.auth.forgotPassword({
-   *   email: "customer@example.com"
-   * });
-   *
-   * if (error) {
-   *   console.error("Password reset failed:", error.message);
-   * } else {
-   *   console.log("Reset email sent successfully");
-   *   // Show confirmation message to user
-   * }
-   * ```
-   */
-  async forgotPassword(body) {
-    return this.executeRequest(
-      () => this.client.POST("/auth/forgot-password", {
-        body
-      })
-    );
-  }
-  /**
-   * Reset password
-   *
-   * @param body - Reset password request body containing new password and OTP token
-   * @returns Promise with new access and refresh tokens
-   * @example
-   * ```typescript
-   * // Reset password with OTP token from forgot password flow
-   * const { data, error } = await sdk.auth.resetPassword({
-   *   new_password: "newSecurePassword123",
-   *   confirm_password: "newSecurePassword123",
-   *   otp_token: "abc123otptoken"
-   * });
-   *
-   * if (error) {
-   *   console.error("Password reset failed:", error.message);
-   * } else {
-   *   console.log("Password reset successful");
-   *   console.log("New access token:", data.access_token);
-   * }
-   * ```
-   */
-  async resetPassword(body) {
-    return this.executeRequest(
-      () => this.client.POST("/auth/reset-password", {
-        body
-      })
-    );
-  }
-  /**
-   * Change password
-   *
-   * @param body - Change password request body containing old and new passwords
-   * @returns Promise with new access and refresh tokens
-   * @example
-   * ```typescript
-   * // Change user's password
-   * const { data, error } = await sdk.auth.changePassword({
-   *   old_password: "currentPassword123",
-   *   new_password: "newSecurePassword456",
-   *   confirm_password: "newSecurePassword456"
-   * });
-   *
-   * if (error) {
-   *   console.error("Password change failed:", error.message);
-   * } else {
-   *   console.log("Password changed successfully");
-   *   console.log("New access token:", data.access_token);
-   * }
-   * ```
-   */
-  async changePassword(body) {
-    return this.executeRequest(
-      () => this.client.POST("/auth/change-password", {
-        body
-      })
-    );
-  }
-  /**
-   * Verify OTP
-   *
-   * @param body - OTP verification data including code and tokens
-   * @returns Promise with user info and tokens
-   * @example
-   * ```typescript
-   * // Verify OTP after login attempt
-   * const { data, error } = await sdk.auth.verifyOtp({
-   *   otp: "1234",
-   *   otpToken: "56895455",
-   *   otpAction: "login" // or "register"
-   * });
-   *
-   * if (error) {
-   *   console.error("OTP verification failed:", error.message);
-   *   // Show error message, allow retry
-   * } else {
-   *   console.log("Login successful:", data.user.email);
-   *   console.log("User ID:", data.user.id);
-   * }
-   * ```
-   */
-  async verifyOtp(body) {
-    return this.executeRequest(
-      () => this.client.POST("/auth/verify-otp", {
-        body
-      })
-    );
-  }
-  /**
-   * Register with phone
-   *
-   * @param body - Registration details including phone number and user information
-   * @returns Promise with user info and tokens
-   * @example
-   * ```typescript
-   * // Register a new user with phone number
-   * const { data, error } = await sdk.auth.registerWithPhone({
-   *   phone: "9876543210",
-   *   country_code: "+91",
-   *   first_name: "John",
-   *   last_name: "Doe",
-   *   email: "john.doe@example.com"
-   * });
-   *
-   * if (error) {
-   *   console.error("Phone registration failed:", error.message);
-   * } else {
-   *   console.log("Registration successful:", data.user.first_name);
-   *   console.log("User ID:", data.user.id);
-   *   console.log("Access token:", data.access_token);
-   * }
-   * ```
-   */
-  async registerWithPhone(body) {
-    return this.executeRequest(
-      () => this.client.POST("/auth/register/phone", {
-        body
-      })
-    );
-  }
-  /**
-   * Register with email
-   *
-   * @param body - Registration details including email and user information
-   * @returns Promise with user info and tokens
-   * @example
-   * ```typescript
-   * // Register a new user with email address
-   * const { data, error } = await sdk.auth.registerWithEmail({
-   *   email: "jane.smith@example.com",
-   *   first_name: "Jane",
-   *   last_name: "Smith",
-   *   phone: "9876543210"
-   * });
-   *
-   * if (error) {
-   *   console.error("Email registration failed:", error.message);
-   * } else {
-   *   console.log("Registration successful:", data.user.email);
-   *   console.log("User ID:", data.user.id);
-   *   console.log("Access token:", data.access_token);
-   * }
-   * ```
-   */
-  async registerWithEmail(body) {
-    return this.executeRequest(
-      () => this.client.POST("/auth/register/email", {
-        body
-      })
-    );
-  }
-  /**
-   * Refresh the access token using a refresh token
-   * @param body - Request body containing the refresh token
-   * @returns Promise with the new access token and refresh token
-   * @example
-   * ```typescript
-   * // Refresh access token when it expires
-   * const { data, error } = await sdk.auth.refreshToken({
-   *   refresh_token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
-   * });
-   *
-   * if (error) {
-   *   console.error("Token refresh failed:", error.message);
-   *   // Redirect to login
-   * } else {
-   *   console.log("Token refreshed successfully");
-   *   console.log("New access token:", data.access_token);
-   *   console.log("New refresh token:", data.refresh_token);
-   * }
-   * ```
-   */
-  async refreshToken(body) {
-    return this.executeRequest(
-      () => this.client.POST("/auth/refresh-token", {
-        body
-      })
-    );
-  }
-  /**
-   * Logout
-   *
-   * @returns Promise that resolves when logout is complete
-   * @example
-   * ```typescript
-   * // Logout current user
-   * const { data, error } = await sdk.auth.logout();
-   *
-   * if (error) {
-   *   console.error("Logout failed:", error.message);
-   * } else {
-   *   console.log("Logout successful");
-   *   console.log("Session ended for user:", data.user.email);
-   * }
-   * ```
-   */
-  async logout() {
-    return this.executeRequest(() => this.client.POST("/auth/logout"));
-  }
-  /**
-   * Get user details
-   *
-   * @param pathParams - Path parameters containing user ID
-   * @returns Promise with user details
-   * @example
-   * ```typescript
-   * // Get details for a specific user
-   * const { data, error } = await sdk.auth.getUserDetails({
-   *   id: "01H9XYZ12345USERID"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get user details:", error.message);
-   * } else {
-   *   console.log("User details:", data.user);
-   *   console.log("Email:", data.user.email);
-   *   console.log("Phone:", data.user.phoneNumber);
-   *   console.log("Created:", data.user.createdAt);
-   * }
-   * ```
-   */
-  async getUserDetails(pathParams) {
-    return this.executeRequest(
-      () => this.client.GET("/auth/user/{id}", {
-        params: {
-          path: pathParams
-        }
-      })
-    );
-  }
-  /**
-   * Update user details
-   *
-   * @param pathParams - Path parameters containing user ID
-   * @param body - Updated user information
-   * @returns Promise with updated user details
-   * @example
-   * ```typescript
-   * // Update user profile information
-   * const { data, error } = await sdk.auth.updateUserDetails(
-   *   { id: "01H9XYZ12345USERID" },
-   *   {
-   *     first_name: "John",
-   *     last_name: "Doe",
-   *     email: "john.doe@example.com",
-   *     phone: "9876543210",
-   *     country_code: "+91"
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to update user:", error.message);
-   * } else {
-   *   console.log("User updated successfully:", data.user.first_name);
-   * }
-   * ```
-   */
-  async updateUserDetails(pathParams, body) {
-    return this.executeRequest(
-      () => this.client.PUT("/auth/user/{id}", {
-        params: {
-          path: pathParams
-        },
-        body
-      })
-    );
-  }
-  /**
-   * Add profile image
-   *
-   * @param pathParams - Path parameters containing user ID
-   * @param formData - Form data containing the image file
-   * @returns Promise with profile image URL
-   * @example
-   * ```typescript
-   * // Add profile image for a user
-   * const imageFile = document.getElementById('file-input').files[0];
-   * const { data, error } = await sdk.auth.addProfileImage(
-   *   { id: "01H9XYZ12345USERID" },
-   *   { image: imageFile }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to add profile image:", error.message);
-   * } else {
-   *   console.log("Profile image added successfully");
-   *   console.log("Image URL:", data.profile_image_url);
-   * }
-   * ```
-   */
-  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 pathParams - Path parameters containing user ID
-   * @param formData - Form data containing the new image file
-   * @returns Promise with updated profile image URL
-   * @example
-   * ```typescript
-   * // Update existing profile image
-   * const newImageFile = document.getElementById('file-input').files[0];
-   * const { data, error } = await sdk.auth.updateProfileImage(
-   *   { id: "01H9XYZ12345USERID" },
-   *   { image: newImageFile }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to update profile image:", error.message);
-   * } else {
-   *   console.log("Profile image updated successfully");
-   *   console.log("New image URL:", data.profile_image_url);
-   * }
-   * ```
-   */
-  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 pathParams - Path parameters containing user ID
-   * @returns Promise with deletion confirmation
-   * @example
-   * ```typescript
-   * // Delete user's profile image
-   * const { data, error } = await sdk.auth.deleteProfileImage({
-   *   id: "01H9XYZ12345USERID"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to delete profile image:", error.message);
-   * } else {
-   *   console.log("Profile image deleted successfully");
-   *   console.log("Success:", data.success);
-   * }
-   * ```
-   */
-  async deleteProfileImage(pathParams) {
-    return this.executeRequest(
-      () => this.client.DELETE("/auth/user/{id}/profile-image", {
-        params: {
-          path: pathParams
-        }
-      })
-    );
-  }
-  /**
-   * Get profile image
-   *
-   * @param pathParams - Path parameters containing user ID
-   * @returns Promise with profile image URL
-   * @example
-   * ```typescript
-   * // Get user's profile image URL
-   * const { data, error } = await sdk.auth.getProfileImage({
-   *   id: "01H9XYZ12345USERID"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get profile image:", error.message);
-   * } else {
-   *   console.log("Profile image URL:", data.profile_image_url);
-   * }
-   * ```
-   */
-  async getProfileImage(pathParams) {
-    return this.executeRequest(
-      () => this.client.GET("/auth/user/{id}/profile-image", {
-        params: {
-          path: pathParams
-        }
-      })
-    );
-  }
-  /**
-   * Deactivate user account
-   *
-   * @param pathParams - Path parameters containing user ID
-   * @returns Promise with deactivation confirmation
-   * @example
-   * ```typescript
-   * // Deactivate a user account
-   * const { data, error } = await sdk.auth.deactivateUserAccount({
-   *   id: "01H9XYZ12345USERID"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to deactivate account:", error.message);
-   * } else {
-   *   console.log("Account deactivated successfully");
-   *   console.log("Success:", data.success);
-   * }
-   * ```
-   */
-  async deactivateUserAccount(pathParams) {
-    return this.executeRequest(
-      () => this.client.PUT("/auth/user/{id}/deactivate", {
-        params: {
-          path: pathParams
-        }
-      })
-    );
-  }
-  /**
-   * Get user notification preferences
-   *
-   * @param pathParams - Path parameters containing user ID
-   * @returns Promise with user's notification preferences
-   * @example
-   * ```typescript
-   * // Get user's notification preferences
-   * const { data, error } = await sdk.auth.getUserNotificationPreferences({
-   *   id: "01H9XYZ12345USERID"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get preferences:", error.message);
-   * } else {
-   *   console.log("Notification preferences:", data.notification_preferences);
-   * }
-   * ```
-   */
-  async getUserNotificationPreferences(pathParams) {
-    return this.executeRequest(
-      () => this.client.GET("/auth/user/{id}/notification-preferences", {
-        params: {
-          path: pathParams
-        }
-      })
-    );
-  }
-  /**
-   * Update user notification preferences
-   *
-   * @param pathParams - Path parameters containing user ID
-   * @param body - Updated notification preferences
-   * @returns Promise with updated notification preferences
-   * @example
-   * ```typescript
-   * // Update user's notification preferences
-   * const { data, error } = await sdk.auth.updateUserNotificationPreferences(
-   *   { id: "01H9XYZ12345USERID" },
-   *   {
-   *     email_notifications: true,
-   *     sms_notifications: false,
-   *     push_notifications: true
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to update preferences:", error.message);
-   * } else {
-   *   console.log("Preferences updated successfully");
-   * }
-   * ```
-   */
-  async updateUserNotificationPreferences(pathParams, body) {
-    return this.executeRequest(
-      () => this.client.PUT("/auth/user/{id}/notification-preferences", {
-        params: {
-          path: pathParams
-        },
-        body
-      })
-    );
-  }
-  /**
-   * Create user notification preference
-   *
-   * @param pathParams - Path parameters containing user ID
-   * @param body - Notification preferences to create
-   * @returns Promise with created notification preferences
-   * @example
-   * ```typescript
-   * // Create notification preferences for a user
-   * const { data, error } = await sdk.auth.createUserNotificationPreference(
-   *   { id: "01H9XYZ12345USERID" },
-   *   {
-   *     email_notifications: true,
-   *     sms_notifications: true,
-   *     push_notifications: false
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to create preferences:", error.message);
-   * } else {
-   *   console.log("Preferences created successfully");
-   * }
-   * ```
-   */
-  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 (phone or email)
-   * @returns Promise with OTP token and action
-   * @example
-   * ```typescript
-   * // Generate OTP for phone number
-   * const { data, error } = await sdk.auth.generateOtp({
-   *   phone: "9876543210",
-   *   country_code: "+91"
-   * });
-   *
-   * if (error) {
-   *   console.error("OTP generation failed:", error.message);
-   * } else {
-   *   console.log("OTP sent successfully");
-   *   console.log("OTP token:", data.otp_token);
-   *   console.log("Action:", data.otp_action);
-   * }
-   * ```
-   */
-  async generateOtp(body) {
-    return this.executeRequest(
-      () => this.client.POST("/auth/generate-otp", {
-        body
-      })
-    );
-  }
-  /**
-   * Check whether email or phone is already verified
-   *
-   * @param body - Request body containing phone numbers or email addresses to verify
-   * @returns Promise with verification status for provided contacts
-   * @example
-   * ```typescript
-   * // Check verification status for multiple contacts
-   * const { data, error } = await sdk.auth.checkEmailOrPhoneIsVerified({
-   *   phone: ["9876543210", "9123456789"],
-   *   email: ["user1@example.com", "user2@example.com"]
-   * });
-   *
-   * if (error) {
-   *   console.error("Verification check failed:", error.message);
-   * } else {
-   *   console.log("Verified phones:", data.verified_phone);
-   *   console.log("Verified emails:", data.verified_email);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.order.getOrderDetails({
-   *   order_number: "ORD-2024-001"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get order details:", error.message);
-   * } else {
-   *   console.log("Order details:", data.content.order);
-   *   console.log("Order status:", data.content.order.status);
-   *   console.log("Total amount:", data.content.order.total_amount);
-   * }
-   * ```
-   */
-  async getOrderDetails(pathParams) {
-    return this.executeRequest(
-      () => this.client.GET("/orders/{order_number}", {
-        params: {
-          path: pathParams
-        }
-      })
-    );
-  }
-  /**
-   * Create order
-   *
-   * @param body - Order creation request body
-   * @returns Promise with order details
-   * @example
-   * ```typescript
-   * // Example with PayU payment gateway
-   * const { data, error } = await sdk.order.createOrder({
-   *   cart_id: "cart_01H9XYZ12345ABCDE",
-   *   payment_gateway: "PAYU",
-   *   payment_gateway_params: {
-   *     payment_gateway: "PAYU",
-   *     furl: "https://yourapp.com/payment/failure",
-   *     surl: "https://yourapp.com/payment/success"
-   *   }
-   * });
-   *
-   * // Example with Juspay payment gateway
-   * const { data, error } = await sdk.order.createOrder({
-   *   cart_id: "cart_01H9XYZ12345ABCDE",
-   *   payment_gateway: "JUSPAY",
-   *   payment_gateway_params: {
-   *     payment_gateway: "JUSPAY",
-   *     action: "paymentPage",
-   *     integration_type: "hyper-checkout",
-   *     return_url: "https://yourapp.com/payment/return",
-   *     gateway_reference_id: "juspay_gateway_ref_123"
-   *   }
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to create order:", error.message);
-   * } else {
-   *   console.log("Order created:", data.content.order.id);
-   *   console.log("Payment required:", data.content.payment_required);
-   *   console.log("Payment info:", data.content.payment_info);
-   * }
-   * ```
-   */
-  async createOrder(body) {
-    return this.executeRequest(
-      () => this.client.POST("/orders", {
-        body
-      })
-    );
-  }
-  /**
-   * List all orders
-   *
-   * @param queryParams - Query parameters for filtering and pagination
-   * @returns Promise with order list
-   * @example
-   * ```typescript
-   * // Basic usage - only required parameter
-   * const { data, error } = await sdk.order.listOrders({
-   *   user_id: "user_01H9XYZ12345ABCDE"
-   * });
-   *
-   * // Advanced usage with optional parameters
-   * const { data, error } = await sdk.order.listOrders({
-   *   user_id: "user_01H9XYZ12345ABCDE",
-   *   page: 1,
-   *   limit: 20,
-   *   sort_by: '{"created_at":"desc"}',
-   *   status: ["confirmed", "shipped", "delivered"]
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to list orders:", error.message);
-   * } else {
-   *   console.log("Orders found:", data.content.orders?.length || 0);
-   *   console.log("Pagination:", data.content.pagination);
-   *
-   *   data.content.orders?.forEach(order => {
-   *     console.log(`Order ${order.order_number}: ${order.status}`);
-   *   });
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.order.getPaymentStatus("ORD-2024-001");
-   *
-   * if (error) {
-   *   console.error("Failed to get payment status:", error.message);
-   * } else {
-   *   console.log("Payment status:", data.content.status);
-   *   console.log("Amount paid:", data.content.amount_paid);
-   *   console.log("Amount unpaid:", data.content.amount_unpaid);
-   *   console.log("Retry available:", data.content.is_retry_available);
-   * }
-   * ```
-   */
-  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 pathParams - Order number path parameters
-   * @returns Promise with shipments
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.order.listOrderShipments({
-   *   order_number: "ORD-2024-001"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get order shipments:", error.message);
-   * } else {
-   *   console.log("Shipments found:", data.content.shipments?.length || 0);
-   *
-   *   data.content.shipments?.forEach(shipment => {
-   *     console.log(`Shipment ${shipment.id}: ${shipment.status}`);
-   *     console.log("Tracking number:", shipment.tracking_number);
-   *     console.log("Carrier:", shipment.carrier);
-   *   });
-   * }
-   * ```
-   */
-  async listOrderShipments(pathParams) {
-    return this.executeRequest(
-      () => this.client.GET("/orders/{order_number}/shipments", {
-        params: {
-          path: pathParams
-        }
-      })
-    );
-  }
-  /**
-   * List order payments
-   *
-   * @param pathParams - Order number path parameters
-   * @returns Promise with payments
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.order.listOrderPayments({
-   *   order_number: "ORD-2024-001"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get order payments:", error.message);
-   * } else {
-   *   console.log("Payments found:", data.content.payments?.length || 0);
-   *
-   *   data.content.payments?.forEach(payment => {
-   *     console.log(`Payment ${payment.id}: ${payment.status}`);
-   *     console.log("Amount:", payment.amount);
-   *     console.log("Gateway:", payment.payment_gateway);
-   *     console.log("Transaction ID:", payment.transaction_id);
-   *   });
-   * }
-   * ```
-   */
-  async listOrderPayments(pathParams) {
-    return this.executeRequest(
-      () => this.client.GET("/orders/{order_number}/payments", {
-        params: {
-          path: pathParams
-        }
-      })
-    );
-  }
-  /**
-   * List order refunds
-   *
-   * @param pathParams - Order number path parameters
-   * @returns Promise with refunds
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.order.listOrderRefunds({
-   *   order_number: "ORD-2024-001"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get order refunds:", error.message);
-   * } else {
-   *   console.log("Refunds found:", data.content.refunds?.length || 0);
-   *
-   *   data.content.refunds?.forEach(refund => {
-   *     console.log(`Refund ${refund.id}: ${refund.status}`);
-   *     console.log("Amount:", refund.amount);
-   *     console.log("Reason:", refund.reason);
-   *     console.log("Processed at:", refund.processed_at);
-   *   });
-   * }
-   * ```
-   */
-  async listOrderRefunds(pathParams) {
-    return this.executeRequest(
-      () => this.client.GET("/orders/{order_number}/refunds", {
-        params: {
-          path: pathParams
-        }
-      })
-    );
-  }
-  /**
-   * Cancel an order
-   *
-   * @param pathParams - Order number path parameters
-   * @param body - Cancellation request body
-   * @returns Promise with order details
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.order.cancelOrder(
-   *   { order_number: "ORD-2024-001" },
-   *   {
-   *     cancellation_reason: "Customer requested cancellation",
-   *     refund_mode: "original_payment_mode",
-   *     feedback: "Customer changed their mind about the purchase"
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to cancel order:", error.message);
-   * } else {
-   *   console.log("Order cancelled successfully");
-   *   console.log("Updated order status:", data.content.order?.status);
-   *   console.log("Cancellation reason:", data.content.order?.cancellation_reason);
-   * }
-   * ```
-   */
-  async cancelOrder(pathParams, body) {
-    return this.executeRequest(
-      () => this.client.POST("/orders/{order_number}/cancel", {
-        params: {
-          path: pathParams
-        },
-        body
-      })
-    );
-  }
-  /**
-   * Retry payment for an order
-   *
-   * @param pathParams - Order number path parameters
-   * @param body - Payment retry request body
-   * @returns Promise with payment information
-   * @example
-   * ```typescript
-   * // Example with PayU payment gateway
-   * const { data, error } = await sdk.order.retryOrderPayment(
-   *   { order_number: "ORD-2024-001" },
-   *   {
-   *     payment_gateway_params: {
-   *       payment_gateway: "PAYU",
-   *       furl: "https://yourapp.com/payment/failure",
-   *       surl: "https://yourapp.com/payment/success"
-   *     }
-   *   }
-   * );
-   *
-   * // Example with Juspay payment gateway
-   * const { data, error } = await sdk.order.retryOrderPayment(
-   *   { order_number: "ORD-2024-001" },
-   *   {
-   *     payment_gateway_params: {
-   *       payment_gateway: "JUSPAY",
-   *       action: "paymentPage",
-   *       integration_type: "hyper-checkout",
-   *       return_url: "https://yourapp.com/payment/return",
-   *       gateway_reference_id: "juspay_gateway_ref_123"
-   *     }
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to retry payment:", error.message);
-   * } else {
-   *   console.log("Payment retry initiated");
-   *   console.log("Payment info:", data.content.payment_info);
-   *   console.log("Transaction ID:", data.content.payment_info.transaction_id);
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.shipping.getShippingMethods({
-   *   delivery_pincode: "400001",
-   *   cart_id: "cart_01H9XYZ12345ABCDE"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get shipping methods:", error.message);
-   * } else {
-   *   console.log("Is serviceable:", data.content.is_serviceable);
-   *   console.log("Available shipping methods:", data.content.shipping_methods?.length || 0);
-   *
-   *   data.content.shipping_methods?.forEach(method => {
-   *     console.log(`Method: ${method.name} (${method.shipping_type})`);
-   *     console.log(`Shipping cost: ${method.shipping_amount}`);
-   *     console.log(`Estimated delivery: ${method.estimated_delivery_days} days`);
-   *
-   *     method.courier_companies?.forEach(courier => {
-   *       console.log(`  - ${courier.name}: ${courier.shipping_amount} (${courier.mode})`);
-   *       console.log(`    Rating: ${courier.rating}/5, Recommended: ${courier.is_recommended}`);
-   *     });
-   *   });
-   * }
-   * ```
-   */
-  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
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.shipping.checkPincodeDeliverability({
-   *   pincode: "400001"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to check pincode serviceability:", error.message);
-   * } else {
-   *   console.log("Pincode serviceable:", data.content.is_serviceable);
-   *
-   *   if (data.content.is_serviceable) {
-   *     console.log("Delivery is available to this pincode");
-   *   } else {
-   *     console.log("Delivery is not available to this pincode");
-   *   }
-   * }
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.helpers.listCountries();
-   *
-   * if (error) {
-   *   console.error("Failed to get countries:", error);
-   *   return;
-   * }
-   *
-   * console.log("Countries found:", data.countries?.length || 0);
-   *
-   * data.countries?.forEach(country => {
-   *   console.log(`Country: ${country.name} (${country.iso_code})`);
-   *   console.log("Phone code:", country.phone_code);
-   *   console.log("Currency:", country.currency?.code);
-   * });
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.helpers.listCountryStates({
-   *   country_iso_code: "IN"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get states:", error);
-   *   return;
-   * }
-   *
-   * console.log("States found:", data.states?.length || 0);
-   *
-   * data.states?.forEach(state => {
-   *   console.log(`State: ${state.name} (${state.iso_code})`);
-   *   console.log("Type:", state.type);
-   * });
-   *
-   * // Get states for different country
-   * const { data: usStates, error: usError } = await sdk.helpers.listCountryStates({
-   *   country_iso_code: "US"
-   * });
-   *
-   * if (usError) {
-   *   console.error("Failed to get US states:", usError);
-   *   return;
-   * }
-   *
-   * console.log("US States:", usStates.states?.map(s => s.name).join(", "));
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.helpers.listCountryPincodes({
-   *   country_iso_code: "IN"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get pincodes:", error);
-   *   return;
-   * }
-   *
-   * console.log("Pincodes found:", data.pincodes?.length || 0);
-   *
-   * data.pincodes?.forEach(pincode => {
-   *   console.log(`Pincode: ${pincode.pincode} - ${pincode.city}, ${pincode.state}`);
-   *   console.log("District:", pincode.district);
-   *   console.log("Area:", pincode.area);
-   * });
-   *
-   * // Get pincodes for different country
-   * const { data: usPincodes, error: usError } = await sdk.helpers.listCountryPincodes({
-   *   country_iso_code: "US"
-   * });
-   *
-   * if (usError) {
-   *   console.error("Failed to get US pincodes:", usError);
-   *   return;
-   * }
-   *
-   * console.log("US Pincodes:", usPincodes.pincodes?.map(p => p.pincode).join(", "));
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.customer.createCustomer({
-   *   first_name: "John",
-   *   last_name: "Doe",
-   *   email: "john.doe@example.com",
-   *   phone: "+1234567890",
-   *   password: "securePassword123"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to create customer:", error);
-   *   return;
-   * }
-   *
-   * console.log("Customer created:", data.customer_detail);
-   * ```
-   */
-  async createCustomer(body) {
-    return this.executeRequest(
-      () => this.client.POST("/customers", {
-        body
-      })
-    );
-  }
-  /**
-   * Get customer details
-   *
-   * @param pathParams - Path parameters
-   * @returns Promise with customer details
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.customer.getCustomer({
-   *   id: "customer_123"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get customer:", error);
-   *   return;
-   * }
-   *
-   * console.log("Customer details:", data.customer_detail);
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.customer.updateCustomer(
-   *   { id: "customer_123" },
-   *   {
-   *     first_name: "John",
-   *     last_name: "Smith",
-   *     email: "john.smith@example.com"
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to update customer:", error);
-   *   return;
-   * }
-   *
-   * console.log("Customer updated:", data.customer_detail);
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.customer.listAddresses({
-   *   user_id: "user_456"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to list addresses:", error);
-   *   return;
-   * }
-   *
-   * console.log("Addresses:", data.addresses);
-   * console.log("Pagination:", data.pagination);
-   *
-   * // With pagination
-   * const { data: page2, error: page2Error } = await sdk.customer.listAddresses({
-   *   user_id: "user_456",
-   *   page: 2,
-   *   limit: 10
-   * });
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.customer.createAddress(
-   *   { user_id: "user_456" },
-   *   {
-   *     address_line1: "123 Main Street",
-   *     address_line2: "Apt 4B",
-   *     city: "New York",
-   *     state: "NY",
-   *     country: "US",
-   *     pincode: "10001",
-   *     is_default_billing: true,
-   *     is_default_shipping: false
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to create address:", error);
-   *   return;
-   * }
-   *
-   * console.log("Address created:", data.address);
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.customer.getAddress({
-   *   user_id: "user_456",
-   *   address_id: "addr_789"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get address:", error);
-   *   return;
-   * }
-   *
-   * console.log("Address details:", data.address);
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.customer.updateAddress(
-   *   {
-   *     user_id: "user_456",
-   *     address_id: "addr_789"
-   *   },
-   *   {
-   *     address_line1: "456 Oak Avenue",
-   *     city: "Los Angeles",
-   *     state: "CA",
-   *     pincode: "90210"
-   *   }
-   * );
-   *
-   * if (error) {
-   *   console.error("Failed to update address:", error);
-   *   return;
-   * }
-   *
-   * console.log("Address updated:", data.address);
-   * ```
-   */
-  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 deletion response
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.customer.deleteAddress({
-   *   user_id: "user_456",
-   *   address_id: "addr_789"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to delete address:", error);
-   *   return;
-   * }
-   *
-   * console.log("Address deleted:", data.message);
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.customer.getLoyaltyDetails({
-   *   user_id: "user_456"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get loyalty details:", error);
-   *   return;
-   * }
-   *
-   * console.log("Loyalty info:", data.loyalty);
-   * console.log("Points balance:", data.loyalty_point_balance);
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.customer.listLoyaltyPointsActivity({
-   *   user_id: "user_456"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get loyalty activity:", error);
-   *   return;
-   * }
-   *
-   * console.log("Loyalty activity:", data.loyalty_points_activity);
-   *
-   * // With pagination and sorting
-   * const { data: sortedData, error: sortedError } = await sdk.customer.listLoyaltyPointsActivity({
-   *   user_id: "user_456",
-   *   page: 1,
-   *   limit: 20,
-   *   sort_by: JSON.stringify({ "created_at": "desc" })
-   * });
-   * ```
-   */
-  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
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.customer.listCustomerReviews({
-   *   user_id: "user_456"
-   * });
-   *
-   * if (error) {
-   *   console.error("Failed to get customer reviews:", error);
-   *   return;
-   * }
-   *
-   * console.log("Customer reviews:", data.reviews);
-   * console.log("Ready for review:", data.ready_for_review);
-   * ```
-   */
-  async listCustomerReviews(pathParams) {
-    return this.executeRequest(
-      () => this.client.GET("/customers/{user_id}/reviews", {
-        params: {
-          path: pathParams
-        }
-      })
-    );
-  }
-};
-
-// src/lib/store-config.ts
-var StoreConfigClient = class extends StorefrontAPIClient {
-  /**
-   * Get store config
-   *
-   * @returns Promise with store configuration data
-   *
-   * @example
-   * ```typescript
-   * const { data, error } = await sdk.storeConfig.getStoreConfig();
-   *
-   * if (error) {
-   *   console.error('Failed to get store config:', error.message);
-   *   return;
-   * }
-   *
-   * // Access store configuration data
-   * const storeConfig = data.store_config;
-   * console.log('Store brand:', storeConfig.brand.name);
-   * console.log('Currency:', storeConfig.currency.code);
-   * console.log('KYC enabled:', storeConfig.is_kyc_enabled);
-   * console.log('Customer groups enabled:', storeConfig.is_customer_group_enabled);
-   * ```
-   */
-  async getStoreConfig() {
-    return this.executeRequest(() => this.client.GET("/store/config"));
-  }
-};
-
-// 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;
-  /**
-   * Client for store config-related endpoints
-   */
-  store;
-  /**
-   * 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);
-    this.store = new StoreConfigClient(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);
-    await this.store.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();
-    await this.store.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);
-    this.store.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();
-    this.store.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;
-    this.store["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,
-  StoreConfigClient,
-  StorefrontAPIClient,
-  StorefrontSDK
-});
-//# sourceMappingURL=index.cjs.map