@commercengine/storefront-sdk 0.3.12 → 0.4.1

package/dist/index.global.js

@@ -0,0 +1,2990 @@
+"use strict";
+var CE_SDK = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    AuthClient: () => AuthClient,
+    BrowserTokenStorage: () => BrowserTokenStorage,
+    CartClient: () => CartClient,
+    CatalogClient: () => CatalogClient,
+    CookieTokenStorage: () => CookieTokenStorage,
+    CustomerClient: () => CustomerClient,
+    Environment: () => Environment,
+    HelpersClient: () => HelpersClient,
+    MemoryTokenStorage: () => MemoryTokenStorage,
+    OrderClient: () => OrderClient,
+    ResponseUtils: () => ResponseUtils,
+    ShippingClient: () => ShippingClient,
+    StorefrontAPIClient: () => StorefrontAPIClient,
+    StorefrontSDK: () => StorefrontSDK,
+    default: () => index_default
+  });
+
+  // ../../node_modules/.pnpm/openapi-fetch@0.13.8/node_modules/openapi-fetch/dist/index.js
+  var PATH_PARAM_RE = /\{[^{}]+\}/g;
+  var supportsRequestInitExt = () => {
+    return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
+  };
+  function randomID() {
+    return Math.random().toString(36).slice(2, 11);
+  }
+  function createClient(clientOptions) {
+    let {
+      baseUrl = "",
+      Request: CustomRequest = globalThis.Request,
+      fetch: baseFetch = globalThis.fetch,
+      querySerializer: globalQuerySerializer,
+      bodySerializer: globalBodySerializer,
+      headers: baseHeaders,
+      requestInitExt = void 0,
+      ...baseOptions
+    } = { ...clientOptions };
+    requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
+    baseUrl = removeTrailingSlash(baseUrl);
+    const middlewares = [];
+    async function coreFetch(schemaPath, fetchOptions) {
+      const {
+        baseUrl: localBaseUrl,
+        fetch: fetch2 = baseFetch,
+        Request: Request2 = CustomRequest,
+        headers,
+        params = {},
+        parseAs = "json",
+        querySerializer: requestQuerySerializer,
+        bodySerializer = globalBodySerializer ?? defaultBodySerializer,
+        body,
+        ...init
+      } = fetchOptions || {};
+      let finalBaseUrl = baseUrl;
+      if (localBaseUrl) {
+        finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
+      }
+      let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+      if (requestQuerySerializer) {
+        querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+          ...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+          ...requestQuerySerializer
+        });
+      }
+      const serializedBody = body === void 0 ? void 0 : bodySerializer(
+        body,
+        // Note: we declare mergeHeaders() both here and below because it’s a bit of a chicken-or-egg situation:
+        // bodySerializer() needs all headers so we aren’t dropping ones set by the user, however,
+        // the result of this ALSO sets the lowest-priority content-type header. So we re-merge below,
+        // setting the content-type at the very beginning to be overwritten.
+        // Lastly, based on the way headers work, it’s not a simple “present-or-not” check becauase null intentionally un-sets headers.
+        mergeHeaders(baseHeaders, headers, params.header)
+      );
+      const finalHeaders = mergeHeaders(
+        // with no body, we should not to set Content-Type
+        serializedBody === void 0 || // if serialized body is FormData; browser will correctly set Content-Type & boundary expression
+        serializedBody instanceof FormData ? {} : {
+          "Content-Type": "application/json"
+        },
+        baseHeaders,
+        headers,
+        params.header
+      );
+      const requestInit = {
+        redirect: "follow",
+        ...baseOptions,
+        ...init,
+        body: serializedBody,
+        headers: finalHeaders
+      };
+      let id;
+      let options;
+      let request = new CustomRequest(
+        createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer }),
+        requestInit
+      );
+      let response;
+      for (const key in init) {
+        if (!(key in request)) {
+          request[key] = init[key];
+        }
+      }
+      if (middlewares.length) {
+        id = randomID();
+        options = Object.freeze({
+          baseUrl: finalBaseUrl,
+          fetch: fetch2,
+          parseAs,
+          querySerializer,
+          bodySerializer
+        });
+        for (const m of middlewares) {
+          if (m && typeof m === "object" && typeof m.onRequest === "function") {
+            const result = await m.onRequest({
+              request,
+              schemaPath,
+              params,
+              options,
+              id
+            });
+            if (result) {
+              if (result instanceof CustomRequest) {
+                request = result;
+              } else if (result instanceof Response) {
+                response = result;
+                break;
+              } else {
+                throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+              }
+            }
+          }
+        }
+      }
+      if (!response) {
+        try {
+          response = await fetch2(request, requestInitExt);
+        } catch (error2) {
+          let errorAfterMiddleware = error2;
+          if (middlewares.length) {
+            for (let i = middlewares.length - 1; i >= 0; i--) {
+              const m = middlewares[i];
+              if (m && typeof m === "object" && typeof m.onError === "function") {
+                const result = await m.onError({
+                  request,
+                  error: errorAfterMiddleware,
+                  schemaPath,
+                  params,
+                  options,
+                  id
+                });
+                if (result) {
+                  if (result instanceof Response) {
+                    errorAfterMiddleware = void 0;
+                    response = result;
+                    break;
+                  }
+                  if (result instanceof Error) {
+                    errorAfterMiddleware = result;
+                    continue;
+                  }
+                  throw new Error("onError: must return new Response() or instance of Error");
+                }
+              }
+            }
+          }
+          if (errorAfterMiddleware) {
+            throw errorAfterMiddleware;
+          }
+        }
+        if (middlewares.length) {
+          for (let i = middlewares.length - 1; i >= 0; i--) {
+            const m = middlewares[i];
+            if (m && typeof m === "object" && typeof m.onResponse === "function") {
+              const result = await m.onResponse({
+                request,
+                response,
+                schemaPath,
+                params,
+                options,
+                id
+              });
+              if (result) {
+                if (!(result instanceof Response)) {
+                  throw new Error("onResponse: must return new Response() when modifying the response");
+                }
+                response = result;
+              }
+            }
+          }
+        }
+      }
+      if (response.status === 204 || request.method === "HEAD" || response.headers.get("Content-Length") === "0") {
+        return response.ok ? { data: void 0, response } : { error: void 0, response };
+      }
+      if (response.ok) {
+        if (parseAs === "stream") {
+          return { data: response.body, response };
+        }
+        return { data: await response[parseAs](), response };
+      }
+      let error = await response.text();
+      try {
+        error = JSON.parse(error);
+      } catch {
+      }
+      return { error, response };
+    }
+    return {
+      request(method, url, init) {
+        return coreFetch(url, { ...init, method: method.toUpperCase() });
+      },
+      /** Call a GET endpoint */
+      GET(url, init) {
+        return coreFetch(url, { ...init, method: "GET" });
+      },
+      /** Call a PUT endpoint */
+      PUT(url, init) {
+        return coreFetch(url, { ...init, method: "PUT" });
+      },
+      /** Call a POST endpoint */
+      POST(url, init) {
+        return coreFetch(url, { ...init, method: "POST" });
+      },
+      /** Call a DELETE endpoint */
+      DELETE(url, init) {
+        return coreFetch(url, { ...init, method: "DELETE" });
+      },
+      /** Call a OPTIONS endpoint */
+      OPTIONS(url, init) {
+        return coreFetch(url, { ...init, method: "OPTIONS" });
+      },
+      /** Call a HEAD endpoint */
+      HEAD(url, init) {
+        return coreFetch(url, { ...init, method: "HEAD" });
+      },
+      /** Call a PATCH endpoint */
+      PATCH(url, init) {
+        return coreFetch(url, { ...init, method: "PATCH" });
+      },
+      /** Call a TRACE endpoint */
+      TRACE(url, init) {
+        return coreFetch(url, { ...init, method: "TRACE" });
+      },
+      /** Register middleware */
+      use(...middleware) {
+        for (const m of middleware) {
+          if (!m) {
+            continue;
+          }
+          if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) {
+            throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+          }
+          middlewares.push(m);
+        }
+      },
+      /** Unregister middleware */
+      eject(...middleware) {
+        for (const m of middleware) {
+          const i = middlewares.indexOf(m);
+          if (i !== -1) {
+            middlewares.splice(i, 1);
+          }
+        }
+      }
+    };
+  }
+  function serializePrimitiveParam(name, value, options) {
+    if (value === void 0 || value === null) {
+      return "";
+    }
+    if (typeof value === "object") {
+      throw new Error(
+        "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+      );
+    }
+    return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+  }
+  function serializeObjectParam(name, value, options) {
+    if (!value || typeof value !== "object") {
+      return "";
+    }
+    const values = [];
+    const joiner = {
+      simple: ",",
+      label: ".",
+      matrix: ";"
+    }[options.style] || "&";
+    if (options.style !== "deepObject" && options.explode === false) {
+      for (const k in value) {
+        values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+      }
+      const final2 = values.join(",");
+      switch (options.style) {
+        case "form": {
+          return `${name}=${final2}`;
+        }
+        case "label": {
+          return `.${final2}`;
+        }
+        case "matrix": {
+          return `;${name}=${final2}`;
+        }
+        default: {
+          return final2;
+        }
+      }
+    }
+    for (const k in value) {
+      const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+      values.push(serializePrimitiveParam(finalName, value[k], options));
+    }
+    const final = values.join(joiner);
+    return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+  }
+  function serializeArrayParam(name, value, options) {
+    if (!Array.isArray(value)) {
+      return "";
+    }
+    if (options.explode === false) {
+      const joiner2 = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ",";
+      const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
+      switch (options.style) {
+        case "simple": {
+          return final;
+        }
+        case "label": {
+          return `.${final}`;
+        }
+        case "matrix": {
+          return `;${name}=${final}`;
+        }
+        // case "spaceDelimited":
+        // case "pipeDelimited":
+        default: {
+          return `${name}=${final}`;
+        }
+      }
+    }
+    const joiner = { simple: ",", label: ".", matrix: ";" }[options.style] || "&";
+    const values = [];
+    for (const v of value) {
+      if (options.style === "simple" || options.style === "label") {
+        values.push(options.allowReserved === true ? v : encodeURIComponent(v));
+      } else {
+        values.push(serializePrimitiveParam(name, v, options));
+      }
+    }
+    return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+  }
+  function createQuerySerializer(options) {
+    return function querySerializer(queryParams) {
+      const search = [];
+      if (queryParams && typeof queryParams === "object") {
+        for (const name in queryParams) {
+          const value = queryParams[name];
+          if (value === void 0 || value === null) {
+            continue;
+          }
+          if (Array.isArray(value)) {
+            if (value.length === 0) {
+              continue;
+            }
+            search.push(
+              serializeArrayParam(name, value, {
+                style: "form",
+                explode: true,
+                ...options?.array,
+                allowReserved: options?.allowReserved || false
+              })
+            );
+            continue;
+          }
+          if (typeof value === "object") {
+            search.push(
+              serializeObjectParam(name, value, {
+                style: "deepObject",
+                explode: true,
+                ...options?.object,
+                allowReserved: options?.allowReserved || false
+              })
+            );
+            continue;
+          }
+          search.push(serializePrimitiveParam(name, value, options));
+        }
+      }
+      return search.join("&");
+    };
+  }
+  function defaultPathSerializer(pathname, pathParams) {
+    let nextURL = pathname;
+    for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+      let name = match.substring(1, match.length - 1);
+      let explode = false;
+      let style = "simple";
+      if (name.endsWith("*")) {
+        explode = true;
+        name = name.substring(0, name.length - 1);
+      }
+      if (name.startsWith(".")) {
+        style = "label";
+        name = name.substring(1);
+      } else if (name.startsWith(";")) {
+        style = "matrix";
+        name = name.substring(1);
+      }
+      if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) {
+        continue;
+      }
+      const value = pathParams[name];
+      if (Array.isArray(value)) {
+        nextURL = nextURL.replace(match, serializeArrayParam(name, value, { style, explode }));
+        continue;
+      }
+      if (typeof value === "object") {
+        nextURL = nextURL.replace(match, serializeObjectParam(name, value, { style, explode }));
+        continue;
+      }
+      if (style === "matrix") {
+        nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+        continue;
+      }
+      nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+    }
+    return nextURL;
+  }
+  function defaultBodySerializer(body, headers) {
+    if (body instanceof FormData) {
+      return body;
+    }
+    if (headers) {
+      const contentType = headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"];
+      if (contentType === "application/x-www-form-urlencoded") {
+        return new URLSearchParams(body).toString();
+      }
+    }
+    return JSON.stringify(body);
+  }
+  function createFinalURL(pathname, options) {
+    let finalURL = `${options.baseUrl}${pathname}`;
+    if (options.params?.path) {
+      finalURL = defaultPathSerializer(finalURL, options.params.path);
+    }
+    let search = options.querySerializer(options.params.query ?? {});
+    if (search.startsWith("?")) {
+      search = search.substring(1);
+    }
+    if (search) {
+      finalURL += `?${search}`;
+    }
+    return finalURL;
+  }
+  function mergeHeaders(...allHeaders) {
+    const finalHeaders = new Headers();
+    for (const h of allHeaders) {
+      if (!h || typeof h !== "object") {
+        continue;
+      }
+      const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
+      for (const [k, v] of iterator) {
+        if (v === null) {
+          finalHeaders.delete(k);
+        } else if (Array.isArray(v)) {
+          for (const v2 of v) {
+            finalHeaders.append(k, v2);
+          }
+        } else if (v !== void 0) {
+          finalHeaders.set(k, v);
+        }
+      }
+    }
+    return finalHeaders;
+  }
+  function removeTrailingSlash(url) {
+    if (url.endsWith("/")) {
+      return url.substring(0, url.length - 1);
+    }
+    return url;
+  }
+
+  // ../../node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/buffer_utils.js
+  var encoder = new TextEncoder();
+  var decoder = new TextDecoder();
+  var MAX_INT32 = 2 ** 32;
+
+  // ../../node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/base64.js
+  function decodeBase64(encoded) {
+    if (Uint8Array.fromBase64) {
+      return Uint8Array.fromBase64(encoded);
+    }
+    const binary = atob(encoded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+
+  // ../../node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/util/base64url.js
+  function decode(input) {
+    if (Uint8Array.fromBase64) {
+      return Uint8Array.fromBase64(typeof input === "string" ? input : decoder.decode(input), {
+        alphabet: "base64url"
+      });
+    }
+    let encoded = input;
+    if (encoded instanceof Uint8Array) {
+      encoded = decoder.decode(encoded);
+    }
+    encoded = encoded.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "");
+    try {
+      return decodeBase64(encoded);
+    } catch {
+      throw new TypeError("The input to be decoded is not correctly encoded.");
+    }
+  }
+
+  // ../../node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/util/errors.js
+  var JOSEError = class extends Error {
+    static code = "ERR_JOSE_GENERIC";
+    code = "ERR_JOSE_GENERIC";
+    constructor(message, options) {
+      super(message, options);
+      this.name = this.constructor.name;
+      Error.captureStackTrace?.(this, this.constructor);
+    }
+  };
+  var JWTInvalid = class extends JOSEError {
+    static code = "ERR_JWT_INVALID";
+    code = "ERR_JWT_INVALID";
+  };
+
+  // ../../node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/is_object.js
+  function isObjectLike(value) {
+    return typeof value === "object" && value !== null;
+  }
+  var is_object_default = (input) => {
+    if (!isObjectLike(input) || Object.prototype.toString.call(input) !== "[object Object]") {
+      return false;
+    }
+    if (Object.getPrototypeOf(input) === null) {
+      return true;
+    }
+    let proto = input;
+    while (Object.getPrototypeOf(proto) !== null) {
+      proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(input) === proto;
+  };
+
+  // ../../node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/util/decode_jwt.js
+  function decodeJwt(jwt) {
+    if (typeof jwt !== "string")
+      throw new JWTInvalid("JWTs must use Compact JWS serialization, JWT must be a string");
+    const { 1: payload, length } = jwt.split(".");
+    if (length === 5)
+      throw new JWTInvalid("Only JWTs using Compact JWS serialization can be decoded");
+    if (length !== 3)
+      throw new JWTInvalid("Invalid JWT");
+    if (!payload)
+      throw new JWTInvalid("JWTs must contain a payload");
+    let decoded;
+    try {
+      decoded = decode(payload);
+    } catch {
+      throw new JWTInvalid("Failed to base64url decode the payload");
+    }
+    let result;
+    try {
+      result = JSON.parse(decoder.decode(decoded));
+    } catch {
+      throw new JWTInvalid("Failed to parse the decoded payload as JSON");
+    }
+    if (!is_object_default(result))
+      throw new JWTInvalid("Invalid JWT Claims Set");
+    return result;
+  }
+
+  // src/lib/jwt-utils.ts
+  function extractUserInfoFromToken(token) {
+    try {
+      const payload = 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 = decodeJwt(token);
+      if (!payload.exp) return true;
+      const currentTime = Math.floor(Date.now() / 1e3);
+      const expiryTime = payload.exp;
+      return currentTime >= expiryTime - bufferSeconds;
+    } catch (error) {
+      console.warn("Failed to decode JWT token:", error);
+      return true;
+    }
+  }
+  function getUserIdFromToken(token) {
+    const userInfo = extractUserInfoFromToken(token);
+    return userInfo?.id || null;
+  }
+  function isUserLoggedIn(token) {
+    const userInfo = extractUserInfoFromToken(token);
+    return userInfo?.isLoggedIn || false;
+  }
+  function isUserAnonymous(token) {
+    const userInfo = extractUserInfoFromToken(token);
+    return userInfo?.isAnonymous || true;
+  }
+
+  // src/lib/auth-utils.ts
+  function getPathnameFromUrl(url) {
+    try {
+      const urlObj = new URL(url);
+      return urlObj.pathname;
+    } catch {
+      return url.split("?")[0];
+    }
+  }
+  function isAnonymousAuthEndpoint(pathname) {
+    return pathname.endsWith("/auth/anonymous");
+  }
+  function isTokenReturningEndpoint(pathname) {
+    const tokenEndpoints = [
+      "/auth/login/password",
+      "/auth/register/phone",
+      "/auth/register/email",
+      "/auth/verify-otp",
+      "/auth/refresh-token"
+    ];
+    return tokenEndpoints.some((endpoint) => pathname.endsWith(endpoint));
+  }
+  function isLogoutEndpoint(pathname) {
+    return pathname.endsWith("/auth/logout");
+  }
+
+  // src/lib/middleware.ts
+  var MemoryTokenStorage = class {
+    accessToken = null;
+    refreshToken = null;
+    async getAccessToken() {
+      return this.accessToken;
+    }
+    async setAccessToken(token) {
+      this.accessToken = token;
+    }
+    async getRefreshToken() {
+      return this.refreshToken;
+    }
+    async setRefreshToken(token) {
+      this.refreshToken = token;
+    }
+    async clearTokens() {
+      this.accessToken = null;
+      this.refreshToken = null;
+    }
+  };
+  var BrowserTokenStorage = class {
+    accessTokenKey;
+    refreshTokenKey;
+    constructor(prefix = "storefront_") {
+      this.accessTokenKey = `${prefix}access_token`;
+      this.refreshTokenKey = `${prefix}refresh_token`;
+    }
+    async getAccessToken() {
+      if (typeof localStorage === "undefined") return null;
+      return localStorage.getItem(this.accessTokenKey);
+    }
+    async setAccessToken(token) {
+      if (typeof localStorage !== "undefined") {
+        localStorage.setItem(this.accessTokenKey, token);
+      }
+    }
+    async getRefreshToken() {
+      if (typeof localStorage === "undefined") return null;
+      return localStorage.getItem(this.refreshTokenKey);
+    }
+    async setRefreshToken(token) {
+      if (typeof localStorage !== "undefined") {
+        localStorage.setItem(this.refreshTokenKey, token);
+      }
+    }
+    async clearTokens() {
+      if (typeof localStorage !== "undefined") {
+        localStorage.removeItem(this.accessTokenKey);
+        localStorage.removeItem(this.refreshTokenKey);
+      }
+    }
+  };
+  var CookieTokenStorage = class {
+    accessTokenKey;
+    refreshTokenKey;
+    options;
+    constructor(options = {}) {
+      const prefix = options.prefix || "storefront_";
+      this.accessTokenKey = `${prefix}access_token`;
+      this.refreshTokenKey = `${prefix}refresh_token`;
+      this.options = {
+        maxAge: options.maxAge || 7 * 24 * 60 * 60,
+        // 7 days default
+        path: options.path || "/",
+        domain: options.domain,
+        secure: options.secure ?? (typeof window !== "undefined" && window.location?.protocol === "https:"),
+        sameSite: options.sameSite || "Lax",
+        httpOnly: false
+        // Must be false for client-side access
+      };
+    }
+    async getAccessToken() {
+      return this.getCookie(this.accessTokenKey);
+    }
+    async setAccessToken(token) {
+      this.setCookie(this.accessTokenKey, token);
+    }
+    async getRefreshToken() {
+      return this.getCookie(this.refreshTokenKey);
+    }
+    async setRefreshToken(token) {
+      this.setCookie(this.refreshTokenKey, token);
+    }
+    async clearTokens() {
+      this.deleteCookie(this.accessTokenKey);
+      this.deleteCookie(this.refreshTokenKey);
+    }
+    getCookie(name) {
+      if (typeof document === "undefined") return null;
+      const value = `; ${document.cookie}`;
+      const parts = value.split(`; ${name}=`);
+      if (parts.length === 2) {
+        const cookieValue = parts.pop()?.split(";").shift();
+        return cookieValue ? decodeURIComponent(cookieValue) : null;
+      }
+      return null;
+    }
+    setCookie(name, value) {
+      if (typeof document === "undefined") return;
+      const encodedValue = encodeURIComponent(value);
+      let cookieString = `${name}=${encodedValue}`;
+      if (this.options.maxAge) {
+        cookieString += `; Max-Age=${this.options.maxAge}`;
+      }
+      if (this.options.path) {
+        cookieString += `; Path=${this.options.path}`;
+      }
+      if (this.options.domain) {
+        cookieString += `; Domain=${this.options.domain}`;
+      }
+      if (this.options.secure) {
+        cookieString += `; Secure`;
+      }
+      if (this.options.sameSite) {
+        cookieString += `; SameSite=${this.options.sameSite}`;
+      }
+      document.cookie = cookieString;
+    }
+    deleteCookie(name) {
+      if (typeof document === "undefined") return;
+      let cookieString = `${name}=; Max-Age=0`;
+      if (this.options.path) {
+        cookieString += `; Path=${this.options.path}`;
+      }
+      if (this.options.domain) {
+        cookieString += `; Domain=${this.options.domain}`;
+      }
+      document.cookie = cookieString;
+    }
+  };
+  function createAuthMiddleware(config) {
+    let isRefreshing = false;
+    let refreshPromise = null;
+    const refreshTokens = async () => {
+      if (isRefreshing && refreshPromise) {
+        return refreshPromise;
+      }
+      isRefreshing = true;
+      refreshPromise = (async () => {
+        try {
+          const refreshToken = await config.tokenStorage.getRefreshToken();
+          let newTokens;
+          if (refreshToken && !isTokenExpired(refreshToken)) {
+            if (config.refreshTokenFn) {
+              newTokens = await config.refreshTokenFn(refreshToken);
+            } else {
+              const response = await fetch(
+                `${config.baseUrl}/auth/refresh-token`,
+                {
+                  method: "POST",
+                  headers: {
+                    "Content-Type": "application/json"
+                  },
+                  body: JSON.stringify({ refresh_token: refreshToken })
+                }
+              );
+              if (!response.ok) {
+                throw new Error(`Token refresh failed: ${response.status}`);
+              }
+              const data = await response.json();
+              newTokens = data.content;
+            }
+          } else {
+            const currentAccessToken = await config.tokenStorage.getAccessToken();
+            if (!currentAccessToken) {
+              throw new Error("No tokens available for refresh");
+            }
+            const reason = refreshToken ? "refresh token expired" : "no refresh token available";
+            const response = await fetch(`${config.baseUrl}/auth/anonymous`, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                ...config.apiKey && { "X-Api-Key": config.apiKey },
+                Authorization: `Bearer ${currentAccessToken}`
+                // For user_id continuity
+              }
+            });
+            if (!response.ok) {
+              throw new Error(
+                `Anonymous token fallback failed: ${response.status}`
+              );
+            }
+            const data = await response.json();
+            newTokens = data.content;
+            console.info(
+              `Token refreshed via anonymous fallback (${reason}) - user may need to re-authenticate for privileged operations`
+            );
+          }
+          await config.tokenStorage.setAccessToken(newTokens.access_token);
+          await config.tokenStorage.setRefreshToken(newTokens.refresh_token);
+          config.onTokensUpdated?.(
+            newTokens.access_token,
+            newTokens.refresh_token
+          );
+        } catch (error) {
+          console.error("Token refresh failed:", error);
+          await config.tokenStorage.clearTokens();
+          config.onTokensCleared?.();
+          throw error;
+        } finally {
+          isRefreshing = false;
+          refreshPromise = null;
+        }
+      })();
+      return refreshPromise;
+    };
+    return {
+      async onRequest({ request }) {
+        const pathname = getPathnameFromUrl(request.url);
+        if (isAnonymousAuthEndpoint(pathname)) {
+          if (config.apiKey) {
+            request.headers.set("X-Api-Key", config.apiKey);
+          }
+          const existingToken = await config.tokenStorage.getAccessToken();
+          if (existingToken) {
+            request.headers.set("Authorization", `Bearer ${existingToken}`);
+          }
+          return request;
+        }
+        let accessToken = await config.tokenStorage.getAccessToken();
+        if (accessToken && isTokenExpired(accessToken)) {
+          try {
+            await refreshTokens();
+            accessToken = await config.tokenStorage.getAccessToken();
+          } catch (error) {
+          }
+        }
+        if (accessToken) {
+          request.headers.set("Authorization", `Bearer ${accessToken}`);
+        }
+        return request;
+      },
+      async onResponse({ request, response }) {
+        const pathname = getPathnameFromUrl(request.url);
+        if (response.ok) {
+          if (isTokenReturningEndpoint(pathname) || isAnonymousAuthEndpoint(pathname)) {
+            try {
+              const data = await response.clone().json();
+              const content = data.content;
+              if (content?.access_token && content?.refresh_token) {
+                await config.tokenStorage.setAccessToken(content.access_token);
+                await config.tokenStorage.setRefreshToken(content.refresh_token);
+                config.onTokensUpdated?.(
+                  content.access_token,
+                  content.refresh_token
+                );
+              }
+            } catch (error) {
+              console.warn("Failed to extract tokens from response:", error);
+            }
+          } else if (isLogoutEndpoint(pathname)) {
+            await config.tokenStorage.clearTokens();
+            config.onTokensCleared?.();
+          }
+        }
+        if (response.status === 401 && !isAnonymousAuthEndpoint(pathname)) {
+          const currentToken = await config.tokenStorage.getAccessToken();
+          if (currentToken && isTokenExpired(currentToken, 0)) {
+            try {
+              await refreshTokens();
+              const newToken = await config.tokenStorage.getAccessToken();
+              if (newToken) {
+                const retryRequest = request.clone();
+                retryRequest.headers.set("Authorization", `Bearer ${newToken}`);
+                return fetch(retryRequest);
+              }
+            } catch (error) {
+              console.warn("Token refresh failed on 401 response:", error);
+            }
+          }
+        }
+        return response;
+      }
+    };
+  }
+  function createDefaultAuthMiddleware(options) {
+    const tokenStorage = options.tokenStorage || (typeof localStorage !== "undefined" ? new BrowserTokenStorage() : new MemoryTokenStorage());
+    return createAuthMiddleware({
+      tokenStorage,
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl,
+      onTokensUpdated: options.onTokensUpdated,
+      onTokensCleared: options.onTokensCleared
+    });
+  }
+
+  // src/lib/logger-utils.ts
+  var ResponseUtils = class {
+    /**
+     * Get response headers as a plain object
+     */
+    static getHeaders(response) {
+      return Object.fromEntries(response.headers.entries());
+    }
+    /**
+     * Get specific header value
+     */
+    static getHeader(response, name) {
+      return response.headers.get(name);
+    }
+    /**
+     * Check if response was successful
+     */
+    static isSuccess(response) {
+      return response.ok;
+    }
+    /**
+     * Get response metadata
+     */
+    static getMetadata(response) {
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        ok: response.ok,
+        url: response.url,
+        redirected: response.redirected,
+        type: response.type,
+        headers: Object.fromEntries(response.headers.entries())
+      };
+    }
+    /**
+     * Clone and read response as text (useful for debugging)
+     * Note: This can only be called once per response
+     */
+    static async getText(response) {
+      const cloned = response.clone();
+      return await cloned.text();
+    }
+    /**
+     * Clone and read response as JSON (useful for debugging)
+     * Note: This can only be called once per response
+     */
+    static async getJSON(response) {
+      const cloned = response.clone();
+      return await cloned.json();
+    }
+    /**
+     * Format response information for debugging
+     */
+    static format(response) {
+      const metadata = this.getMetadata(response);
+      return `${metadata.status} ${metadata.statusText} - ${metadata.url}`;
+    }
+  };
+  var DebugLogger = class {
+    logger;
+    responseTextCache = /* @__PURE__ */ new Map();
+    constructor(logger) {
+      this.logger = logger || ((level, message, data) => {
+        console.log(`[${level.toUpperCase()}]`, message);
+        if (data) console.log(data);
+      });
+    }
+    /**
+     * Log debug information about API request
+     */
+    logRequest(request, requestBody) {
+      this.logger("info", "API Request Debug Info", {
+        method: request.method,
+        url: request.url,
+        headers: Object.fromEntries(request.headers.entries()),
+        body: requestBody,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    /**
+     * Log debug information about API response
+     */
+    async logResponse(response, responseBody) {
+      if (responseBody && typeof responseBody === "string") {
+        this.responseTextCache.set(response.url, responseBody);
+      }
+      this.logger("info", "API Response Debug Info", {
+        url: response.url,
+        status: response.status,
+        statusText: response.statusText,
+        ok: response.ok,
+        headers: Object.fromEntries(response.headers.entries()),
+        redirected: response.redirected,
+        type: response.type,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (responseBody) {
+        this.logger("info", "API Response Data", {
+          data: responseBody,
+          contentType: response.headers.get("content-type"),
+          contentLength: response.headers.get("content-length")
+        });
+      }
+    }
+    /**
+     * Log error information
+     */
+    logError(message, error) {
+      this.logger("error", message, error);
+    }
+    /**
+     * Get cached response text for a URL (if available)
+     */
+    getCachedResponseText(url) {
+      return this.responseTextCache.get(url) || null;
+    }
+    /**
+     * Clear cached response texts
+     */
+    clearCache() {
+      this.responseTextCache.clear();
+    }
+  };
+  async function extractRequestBody(request) {
+    if (request.method === "GET" || request.method === "HEAD") {
+      return null;
+    }
+    try {
+      const clonedRequest = request.clone();
+      const contentType = request.headers.get("content-type")?.toLowerCase();
+      if (contentType?.startsWith("application/json")) {
+        return await clonedRequest.json();
+      } else if (contentType?.startsWith("multipart/form-data")) {
+        return "[FormData - cannot display]";
+      } else if (contentType?.startsWith("text/")) {
+        return await clonedRequest.text();
+      }
+      return "[Request body - unknown format]";
+    } catch (error) {
+      return "[Request body unavailable]";
+    }
+  }
+  function createDebugMiddleware(logger) {
+    const debugLogger = new DebugLogger(logger);
+    return {
+      async onRequest({ request }) {
+        const requestBody = await extractRequestBody(request);
+        debugLogger.logRequest(request, requestBody);
+        return request;
+      },
+      async onResponse({ response }) {
+        const cloned = response.clone();
+        let responseBody = null;
+        try {
+          const contentType = response.headers.get("content-type")?.toLowerCase();
+          if (contentType?.startsWith("application/json")) {
+            responseBody = await cloned.json();
+          } else if (contentType?.startsWith("text/")) {
+            responseBody = await cloned.text();
+          }
+        } catch (error) {
+        }
+        await debugLogger.logResponse(response, responseBody);
+        return response;
+      },
+      async onError({ error, request }) {
+        debugLogger.logError("API Request Failed", {
+          error: {
+            name: error instanceof Error ? error.name : "Unknown",
+            message: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : void 0
+          },
+          request: {
+            method: request.method,
+            url: request.url,
+            headers: Object.fromEntries(request.headers.entries())
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        throw error;
+      }
+    };
+  }
+
+  // src/lib/header-utils.ts
+  var HEADER_TRANSFORMATIONS = {
+    customer_group_id: "x-customer-group-id"
+    // Future transformations can be added here:
+    // some_param: "X-Some-Header",
+    // another_param: "X-Another-Header",
+  };
+  function transformHeaders(headers) {
+    const transformed = {};
+    for (const [key, value] of Object.entries(headers)) {
+      if (value !== void 0) {
+        const headerName = HEADER_TRANSFORMATIONS[key] || key;
+        transformed[headerName] = value;
+      }
+    }
+    return transformed;
+  }
+  function mergeHeaders2(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 = createClient({
+        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 mergeHeaders2(this.config.defaultHeaders, methodHeaders);
+    }
+  };
+
+  // src/lib/catalog.ts
+  var CatalogClient = class extends StorefrontAPIClient {
+    /**
+     * List all products
+     *
+     * @param options - Optional query parameters
+     * @param headers - Optional header parameters (customer_group_id, etc.)
+     * @returns Promise with products and pagination info
+     */
+    async listProducts(options, headers) {
+      const mergedHeaders = this.mergeHeaders(headers);
+      return this.executeRequest(
+        () => this.client.GET("/catalog/products", {
+          params: {
+            query: options,
+            header: mergedHeaders
+          }
+        })
+      );
+    }
+    /**
+     * List all skus
+     *
+     * @param options - Optional query parameters
+     * @param headers - Optional header parameters (customer_group_id, etc.)
+     * @returns Promise with skus and pagination info
+     */
+    async listSkus(options, headers) {
+      const mergedHeaders = this.mergeHeaders(headers);
+      return this.executeRequest(
+        () => this.client.GET("/catalog/skus", {
+          params: {
+            query: options,
+            header: mergedHeaders
+          }
+        })
+      );
+    }
+    /**
+     * Get details for a specific product
+     *
+     * @param pathParams - The path parameters (product ID or slug)
+     * @param headers - Optional header parameters (customer_group_id, etc.)
+     * @returns Promise with product details
+     */
+    async getProductDetail(pathParams, headers) {
+      const mergedHeaders = this.mergeHeaders(headers);
+      return this.executeRequest(
+        () => this.client.GET("/catalog/products/{product_id_or_slug}", {
+          params: {
+            path: pathParams,
+            header: mergedHeaders
+          }
+        })
+      );
+    }
+    /**
+     * List variants for a specific product
+     *
+     * @param pathParams - The path parameters (product ID)
+     * @param headers - Optional header parameters (customer_group_id, etc.)
+     * @returns Promise with variants
+     */
+    async listProductVariants(pathParams, headers) {
+      const mergedHeaders = this.mergeHeaders(headers);
+      return this.executeRequest(
+        () => this.client.GET("/catalog/products/{product_id}/variants", {
+          params: {
+            path: pathParams,
+            header: mergedHeaders
+          }
+        })
+      );
+    }
+    /**
+     * Get details for a specific variant
+     *
+     * @param pathParams - The path parameters (product ID and variant ID)
+     * @param headers - Optional header parameters (customer_group_id, etc.)
+     * @returns Promise with variant details
+     */
+    async getVariantDetail(pathParams, headers) {
+      const mergedHeaders = this.mergeHeaders(headers);
+      return this.executeRequest(
+        () => this.client.GET("/catalog/products/{product_id}/variants/{variant_id}", {
+          params: {
+            path: pathParams,
+            header: mergedHeaders
+          }
+        })
+      );
+    }
+    /**
+     * List all categories
+     *
+     * @param options - Optional query parameters
+     * @returns Promise with categories and pagination info
+     */
+    async listCategories(options) {
+      return this.executeRequest(
+        () => this.client.GET("/catalog/categories", {
+          params: { query: options }
+        })
+      );
+    }
+    /**
+     * List reviews for a specific product
+     *
+     * @param pathParams - The path parameters (product ID)
+     * @param queryParams - Optional query parameters
+     * @returns Promise with reviews and pagination info
+     */
+    async listProductReviews(pathParams, queryParams) {
+      return this.executeRequest(
+        () => this.client.GET("/catalog/products/{product_id}/reviews", {
+          params: {
+            path: pathParams,
+            query: queryParams
+          }
+        })
+      );
+    }
+    /**
+     * Create a review for a specific product
+     *
+     * @param pathParams - The path parameters (product ID)
+     * @param formData - The review data
+     * @returns Promise that resolves when the review is created
+     */
+    async createProductReview(pathParams, formData) {
+      return this.executeRequest(
+        () => this.client.POST("/catalog/products/{product_id}/reviews", {
+          params: {
+            path: pathParams
+          },
+          body: formData,
+          bodySerializer: (body) => {
+            const fd = new FormData();
+            for (const [key, value] of Object.entries(body)) {
+              if (value !== void 0 && value !== null) {
+                if (value instanceof File || value instanceof Blob) {
+                  fd.append(key, value);
+                } else {
+                  fd.append(key, String(value));
+                }
+              }
+            }
+            return fd;
+          }
+        })
+      );
+    }
+    /**
+     * Search for products
+     *
+     * @param searchData - The search parameters
+     * @returns Promise with search results, facet distribution, facet stats, and pagination
+     */
+    async searchProducts(searchData, headers) {
+      const mergedHeaders = this.mergeHeaders(headers);
+      return this.executeRequest(
+        () => this.client.POST("/catalog/products/search", {
+          body: searchData,
+          header: mergedHeaders
+        })
+      );
+    }
+    /**
+     * List cross-sell products
+     *
+     * @param options - Optional query parameters
+     * @param headers - Optional header parameters (customer_group_id, etc.)
+     * @returns Promise with cross-sell products
+     */
+    async listCrossSellProducts(options, headers) {
+      const mergedHeaders = this.mergeHeaders(headers);
+      return this.executeRequest(
+        () => this.client.GET("/catalog/products/cross-sell", {
+          params: {
+            query: options,
+            header: mergedHeaders
+          }
+        })
+      );
+    }
+    /**
+     * List up-sell products
+     *
+     * @param options - Optional query parameters
+     * @param headers - Optional header parameters (customer_group_id, etc.)
+     * @returns Promise with up-sell products
+     */
+    async listUpSellProducts(options, headers) {
+      const mergedHeaders = this.mergeHeaders(headers);
+      return this.executeRequest(
+        () => this.client.GET("/catalog/products/up-sell", {
+          params: {
+            query: options,
+            header: mergedHeaders
+          }
+        })
+      );
+    }
+    /**
+     * List similar products
+     *
+     * @param options - Optional query parameters
+     * @param headers - Optional header parameters (customer_group_id, etc.)
+     * @returns Promise with similar products
+     */
+    async listSimilarProducts(options, headers) {
+      const mergedHeaders = this.mergeHeaders(headers);
+      return this.executeRequest(
+        () => this.client.GET("/catalog/products/similar", {
+          params: {
+            query: options,
+            header: mergedHeaders
+          }
+        })
+      );
+    }
+  };
+
+  // src/lib/cart.ts
+  var CartClient = class extends StorefrontAPIClient {
+    /**
+     * Create a new cart
+     *
+     * @param payload - Object containing the items to add to the cart
+     * @returns Promise with the created cart
+     */
+    async createCart(payload) {
+      return this.executeRequest(
+        () => this.client.POST("/carts", {
+          body: payload
+        })
+      );
+    }
+    /**
+     * Get cart details - either by ID or using the stored cart ID
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise with cart details
+     */
+    async getCart(cartId) {
+      return this.executeRequest(
+        () => this.client.GET("/carts/{id}", {
+          params: {
+            path: cartId
+          }
+        })
+      );
+    }
+    /**
+     * Delete a cart - either by ID or using the stored cart ID
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise that resolves when the cart is deleted
+     */
+    async deleteCart(cartId) {
+      return this.executeRequest(
+        () => this.client.DELETE("/carts/{id}", {
+          params: {
+            path: cartId
+          }
+        })
+      );
+    }
+    /**
+     * Update cart items (add, update quantity, remove)
+     *
+     * @param cartId - The cart id
+     * @param body - The body of the request
+     * @returns Promise with updated cart
+     */
+    async addDeleteCartItem(cartId, body) {
+      return this.executeRequest(
+        () => this.client.POST("/carts/{id}/items", {
+          params: {
+            path: cartId
+          },
+          body
+        })
+      );
+    }
+    /**
+     * Get cart details by user ID
+     *
+     * @param userId - The ID of the user
+     * @returns Promise with cart details
+     */
+    async getUserCart(userId) {
+      return this.executeRequest(
+        () => this.client.GET("/carts/users/{user_id}", {
+          params: {
+            path: userId
+          }
+        })
+      );
+    }
+    /**
+     * Delete a cart by user ID
+     *
+     * @param userId - The ID of the user
+     * @returns Promise that resolves when the cart is deleted
+     */
+    async deleteUserCart(userId) {
+      return this.executeRequest(
+        () => this.client.DELETE("/carts/users/{user_id}", {
+          params: {
+            path: userId
+          },
+          body: void 0
+        })
+      );
+    }
+    /**
+     * Update cart addresses
+     *
+     * @param cartId - The ID of the cart
+     * @param addressData - The address data
+     * @returns Promise with updated cart
+     */
+    async updateCartAddress(cartId, addressData) {
+      return this.executeRequest(
+        () => this.client.POST("/carts/{id}/address", {
+          params: {
+            path: cartId
+          },
+          body: addressData
+        })
+      );
+    }
+    /**
+     * Apply a coupon to the cart
+     *
+     * @param cartId - The ID of the cart
+     * @param couponCode - The coupon code
+     * @returns Promise with updated cart
+     */
+    async applyCoupon(cartId, couponCode) {
+      return this.executeRequest(
+        () => this.client.POST("/carts/{id}/coupon", {
+          params: {
+            path: cartId
+          },
+          body: couponCode
+        })
+      );
+    }
+    /**
+     * Remove a coupon from the cart
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise with updated cart
+     */
+    async removeCoupon(cartId) {
+      return this.executeRequest(
+        () => this.client.DELETE("/carts/{id}/coupon", {
+          params: {
+            path: cartId
+          },
+          body: void 0
+        })
+      );
+    }
+    /**
+     * Redeem loyalty points
+     *
+     * @param cartId - The ID of the cart
+     * @param points - The number of points to redeem
+     * @returns Promise with updated cart
+     */
+    async redeemLoyaltyPoints(cartId, points) {
+      return this.executeRequest(
+        () => this.client.POST("/carts/{id}/loyalty-points", {
+          params: {
+            path: cartId
+          },
+          body: points
+        })
+      );
+    }
+    /**
+     * Remove loyalty points
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise with updated cart
+     */
+    async removeLoyaltyPoints(cartId) {
+      return this.executeRequest(
+        () => this.client.DELETE("/carts/{id}/loyalty-points", {
+          params: {
+            path: cartId
+          },
+          body: void 0
+        })
+      );
+    }
+    /**
+     * Update shipping method
+     *
+     * @param cartId - The ID of the cart
+     * @param body - The body of the request
+     * @returns Promise with updated cart
+     */
+    async updateShippingMethod(cartId, body) {
+      return this.executeRequest(
+        () => this.client.POST("/carts/{id}/shipping-method", {
+          params: {
+            path: cartId
+          },
+          body
+        })
+      );
+    }
+    /**
+     * Use credit balance
+     *
+     * @param cartId - The ID of the cart
+     * @param body - The body of the request
+     * @returns Promise with updated cart
+     */
+    async redeemCreditBalance(cartId, body) {
+      return this.executeRequest(
+        () => this.client.POST("/carts/{id}/credit-balance", {
+          params: {
+            path: cartId
+          },
+          body
+        })
+      );
+    }
+    /**
+     * Remove credit balance
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise with updated cart
+     */
+    async removeCreditBalance(cartId) {
+      return this.executeRequest(
+        () => this.client.DELETE("/carts/{id}/credit-balance", {
+          params: {
+            path: cartId
+          },
+          body: void 0
+        })
+      );
+    }
+    /**
+     * Redeem gift card
+     *
+     * @param cartId - The ID of the cart
+     * @param body - The body of the request
+     * @returns Promise with updated cart
+     */
+    async redeemGiftCard(cartId, body) {
+      return this.executeRequest(
+        () => this.client.POST("/carts/{id}/gift-card", {
+          params: {
+            path: cartId
+          },
+          body
+        })
+      );
+    }
+    /**
+     * Remove gift card
+     *
+     * @param cartId - The ID of the cart
+     * @returns Promise with updated cart
+     */
+    async removeGiftCard(cartId) {
+      return this.executeRequest(
+        () => this.client.DELETE("/carts/{id}/gift-card", {
+          params: {
+            path: cartId
+          },
+          body: void 0
+        })
+      );
+    }
+    /**
+     * Get wishlist items
+     *
+     * @param userId - The ID of the user
+     * @returns Promise with wishlist items
+     */
+    async getWishlist(userId) {
+      return this.executeRequest(
+        () => this.client.GET("/wishlist/{user_id}", {
+          params: {
+            path: userId
+          }
+        })
+      );
+    }
+    /**
+     * Add item to wishlist
+     *
+     * @param userId - The ID of the user
+     * @param itemId - The ID of the item
+     * @returns Promise with updated wishlist
+     */
+    async addToWishlist(userId, itemId) {
+      return this.executeRequest(
+        () => this.client.POST("/wishlist/{user_id}", {
+          params: {
+            path: userId
+          },
+          body: itemId
+        })
+      );
+    }
+    /**
+     * Remove item from wishlist
+     *
+     * @param userId - The ID of the user
+     * @param itemId - The ID of the item
+     * @returns Promise with updated wishlist
+     */
+    async removeFromWishlist(userId, body) {
+      return this.executeRequest(
+        () => this.client.DELETE("/wishlist/{user_id}", {
+          params: {
+            path: userId
+          },
+          body
+        })
+      );
+    }
+    /**
+     * Get all available coupons
+     *
+     * @param headers - Optional header parameters (customer_group_id, etc.)
+     * @returns Promise with all available coupons
+     */
+    async getAvailableCoupons(headers) {
+      const mergedHeaders = this.mergeHeaders(headers);
+      return this.executeRequest(
+        () => this.client.GET("/carts/available-coupons", {
+          params: {
+            header: mergedHeaders
+          }
+        })
+      );
+    }
+    /**
+     * Get all available promotions
+     *
+     * @param headers - Optional header parameters (customer_group_id, etc.)
+     * @returns Promise with all available promotions
+     */
+    async getAvailablePromotions(headers) {
+      const mergedHeaders = this.mergeHeaders(headers);
+      return this.executeRequest(
+        () => this.client.GET("/carts/available-promotions", {
+          params: {
+            header: mergedHeaders
+          }
+        })
+      );
+    }
+  };
+
+  // src/lib/auth.ts
+  var AuthClient = class extends StorefrontAPIClient {
+    /**
+     * Get anonymous token for guest users
+     */
+    async getAnonymousToken() {
+      return this.executeRequest(
+        () => this.client.POST("/auth/anonymous")
+      );
+    }
+    /**
+     * Login with phone number
+     *
+     * @param phoneNumber - Phone number (without country code)
+     * @param countryCode - Country code (defaults to +91)
+     * @param registerIfNotExists - Whether to register if user doesn't exist
+     * @returns Promise with OTP token and action 
+     */
+    async loginWithPhone(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/login/phone", {
+          body
+        })
+      );
+    }
+    /**
+     * Login with WhatsApp
+     *
+     * @param phoneNumber - Phone number (without country code)
+     * @param countryCode - Country code (defaults to +91)
+     * @param registerIfNotExists - Whether to register if user doesn't exist
+     * @returns Promise with OTP token and action
+     */
+    async loginWithWhatsApp(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/login/whatsapp", {
+          body
+        })
+      );
+    }
+    /**
+     * Login with email
+     *
+     * @param email - Email address
+     * @param registerIfNotExists - Whether to register if user doesn't exist
+     * @returns Promise with OTP token and action
+     */
+    async loginWithEmail(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/login/email", {
+          body
+        })
+      );
+    }
+    /**
+     * Login with password
+     *
+     * @param credentials - Login credentials
+     * @returns Promise with user info and tokens
+     */
+    async loginWithPassword(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/login/password", {
+          body
+        })
+      );
+    }
+    /**
+     * Forgot password
+     *
+     * @param email - Email address
+     * @returns Promise with user info and tokens
+     */
+    async forgotPassword(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/forgot-password", {
+          body
+        })
+      );
+    }
+    /**
+     * Reset password
+     *
+     * @param email - Email address
+     * @returns Promise with user info and tokens
+     */
+    async resetPassword(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/reset-password", {
+          body
+        })
+      );
+    }
+    /**
+     * Change password
+     *
+     * @param oldPassword - Old password
+     * @param newPassword - New password
+     * @param newPasswordConfirmation - New password confirmation
+     * @returns Promise with new access token and refresh token
+     */
+    async changePassword(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/change-password", {
+          body
+        })
+      );
+    }
+    /**
+     * Verify OTP
+     *
+     * @param otp - One-time password
+     * @param otpToken - OTP token from login request
+     * @param otpAction - OTP action from login request
+     * @returns Promise with user info and tokens
+     */
+    async verifyOtp(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/verify-otp", {
+          body
+        })
+      );
+    }
+    /**
+     * Register with phone
+     *
+     * @param options - Registration details
+     * @returns Promise with user info and tokens
+     */
+    async registerWithPhone(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/register/phone", {
+          body
+        })
+      );
+    }
+    /**
+     * Register with email
+     *
+     * @param options - Registration details
+     * @returns Promise with user info and tokens
+     */
+    async registerWithEmail(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/register/email", {
+          body
+        })
+      );
+    }
+    /**
+     * Refresh the access token using a refresh token
+     * @param refreshToken - The refresh token to use for refreshing the access token
+     * @returns Promise with the new access token and refresh token
+     */
+    async refreshToken(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/refresh-token", {
+          body
+        })
+      );
+    }
+    /**
+     * Logout
+     *
+     * @returns Promise that resolves when logout is complete
+     */
+    async logout() {
+      return this.executeRequest(
+        () => this.client.POST("/auth/logout")
+      );
+    }
+    /**
+     * Get user details
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
+     */
+    async getUserDetails(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/auth/user/{id}", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * Update user details
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
+     */
+    async updateUserDetails(pathParams, body) {
+      return this.executeRequest(
+        () => this.client.PUT("/auth/user/{id}", {
+          params: {
+            path: pathParams
+          },
+          body
+        })
+      );
+    }
+    /**
+     * Add profile image
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
+     */
+    async addProfileImage(pathParams, formData) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/user/{id}/profile-image", {
+          params: {
+            path: pathParams
+          },
+          body: formData,
+          bodySerializer: (body) => {
+            const fd = new FormData();
+            for (const [key, value] of Object.entries(body)) {
+              if (value !== void 0 && value !== null) {
+                fd.append(key, value);
+              }
+            }
+            return fd;
+          }
+        })
+      );
+    }
+    /**
+     * Update profile image
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
+     */
+    async updateProfileImage(pathParams, formData) {
+      return this.executeRequest(
+        () => this.client.PUT("/auth/user/{id}/profile-image", {
+          params: {
+            path: pathParams
+          },
+          body: formData,
+          bodySerializer: (body) => {
+            const fd = new FormData();
+            for (const [key, value] of Object.entries(body)) {
+              if (value !== void 0 && value !== null) {
+                fd.append(key, value);
+              }
+            }
+            return fd;
+          }
+        })
+      );
+    }
+    /**
+     * Delete profile image
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
+     */
+    async deleteProfileImage(pathParams) {
+      return this.executeRequest(
+        () => this.client.DELETE("/auth/user/{id}/profile-image", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * Get profile image
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
+     */
+    async getProfileImage(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/auth/user/{id}/profile-image", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * Deactivate user account
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
+     */
+    async deactivateUserAccount(pathParams) {
+      return this.executeRequest(
+        () => this.client.PUT("/auth/user/{id}/deactivate", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * Get user notification preferences
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
+     */
+    async getUserNotificationPreferences(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/auth/user/{id}/notification-preferences", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * Update user notification preferences
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
+     */
+    async updateUserNotificationPreferences(pathParams, body) {
+      return this.executeRequest(
+        () => this.client.PUT("/auth/user/{id}/notification-preferences", {
+          params: {
+            path: pathParams
+          },
+          body
+        })
+      );
+    }
+    /**
+     * Create user notification preference
+     *
+     * @param userId - User ID
+     * @returns Promise with user details
+     */
+    async createUserNotificationPreference(pathParams, body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/user/{id}/notification-preferences", {
+          params: {
+            path: pathParams
+          },
+          body
+        })
+      );
+    }
+    /**
+     * Generate OTP
+     * 
+     * @param body - OTP generation body
+     * @returns Promise with OTP generation response
+     */
+    async generateOtp(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/generate-otp", {
+          body
+        })
+      );
+    }
+    /**
+     * Check whether email or phone is already verified
+     *
+     * @param body - OTP generation body
+     * @returns Promise with OTP generation response
+     */
+    async checkEmailOrPhoneIsVerified(body) {
+      return this.executeRequest(
+        () => this.client.POST("/auth/verified-email-phone", {
+          body
+        })
+      );
+    }
+  };
+
+  // src/lib/order.ts
+  var OrderClient = class extends StorefrontAPIClient {
+    /**
+     * Get order details
+     *
+     * @param orderNumber - Order number
+     * @returns Promise with order details
+     */
+    async getOrderDetails(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/orders/{order_number}", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * Create order
+     *
+     * @param cartId - Cart ID
+     * @param paymentGateway - Payment gateway
+     * @param paymentGatewayParams - Params for the selected payment gateway
+     * @returns Promise with order details
+     */
+    async createOrder(body) {
+      return this.executeRequest(
+        () => this.client.POST("/orders", {
+          body
+        })
+      );
+    }
+    /**
+     * List all orders
+     *
+     * @param queryParams - Query parameters
+     * @returns Promise with order details
+     */
+    async listOrders(queryParams) {
+      return this.executeRequest(
+        () => this.client.GET("/orders", {
+          params: {
+            query: queryParams
+          }
+        })
+      );
+    }
+    /**
+     * Get payment status for an order
+     *
+     * @param orderNumber - Order number
+     * @returns Promise with payment status
+     */
+    async getPaymentStatus(orderNumber) {
+      return this.executeRequest(
+        () => this.client.GET("/orders/{order_number}/payment-status", {
+          params: {
+            path: { order_number: orderNumber }
+          }
+        })
+      );
+    }
+    /**
+     * Get all shipments for an order
+     *
+     * @param orderNumber - Order number
+     * @returns Promise with shipments
+     */
+    async listOrderShipments(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/orders/{order_number}/shipments", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * List order payments
+     *
+     * @param orderNumber - Order number
+     * @returns Promise with payments
+     */
+    async listOrderPayments(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/orders/{order_number}/payments", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * List order refunds
+     *
+     * @param orderNumber - Order number
+     * @returns Promise with refunds
+     */
+    async listOrderRefunds(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/orders/{order_number}/refunds", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * Cancel an order
+     *
+     * @param orderNumber - Order number
+     * @returns Promise with order details
+     */
+    async cancelOrder(pathParams, body) {
+      return this.executeRequest(
+        () => this.client.POST("/orders/{order_number}/cancel", {
+          params: {
+            path: pathParams
+          },
+          body
+        })
+      );
+    }
+    /**
+     * Retry payment for an order
+     *
+     * @param orderNumber - Order number
+     * @returns Promise with order details
+     */
+    async retryOrderPayment(pathParams, body) {
+      return this.executeRequest(
+        () => this.client.POST("/orders/{order_number}/retry-payment", {
+          params: {
+            path: pathParams
+          },
+          body
+        })
+      );
+    }
+  };
+
+  // src/lib/shipping.ts
+  var ShippingClient = class extends StorefrontAPIClient {
+    /**
+     * Get shipping options for an order
+     *
+     * @param body - Shipping methods body
+     * @returns Promise with shipping options
+     */
+    async getShippingMethods(body) {
+      return this.executeRequest(
+        () => this.client.POST("/shipping/shipping-methods", {
+          body
+        })
+      );
+    }
+    /**
+     * Check pincode deliverability
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with pincode deliverability result
+     */
+    async checkPincodeDeliverability(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/shipping/serviceability/{pincode}", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+  };
+
+  // src/lib/helper.ts
+  var HelpersClient = class extends StorefrontAPIClient {
+    /**
+     * Get a list of countries
+     *
+     * @returns Promise with countries
+     */
+    async listCountries() {
+      return this.executeRequest(
+        () => this.client.GET("/common/countries", {})
+      );
+    }
+    /**
+     * - Get a list of states for a country
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with states
+     */
+    async listCountryStates(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/common/countries/{country_iso_code}/states", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * Get pincodes for a country
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with pincodes
+     */
+    async listCountryPincodes(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/common/countries/{country_iso_code}/pincodes", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+  };
+
+  // src/lib/customer.ts
+  var CustomerClient = class extends StorefrontAPIClient {
+    /**
+     * Create a customer
+     *
+     * @param body - Customer creation body
+     * @returns Promise with customer details
+     */
+    async createCustomer(body) {
+      return this.executeRequest(
+        () => this.client.POST("/customers", {
+          body
+        })
+      );
+    }
+    /**
+     * Get customer details
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with customer details
+     */
+    async getCustomer(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/customers/{id}", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * Update a customer
+     *
+     * @param pathParams - Path parameters
+     * @param body - Customer update body
+     * @returns Promise with customer details
+     */
+    async updateCustomer(pathParams, body) {
+      return this.executeRequest(
+        () => this.client.PUT("/customers/{id}", {
+          params: {
+            path: pathParams
+          },
+          body
+        })
+      );
+    }
+    /**
+     * Get all saved addresses for a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with addresses
+     */
+    async listAddresses(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/customers/{user_id}/addresses", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * Create a new address for a customer
+     *
+     * @param pathParams - Path parameters
+     * @param body - Address creation body
+     * @returns Promise with address details
+     */
+    async createAddress(pathParams, body) {
+      return this.executeRequest(
+        () => this.client.POST("/customers/{user_id}/addresses", {
+          params: {
+            path: pathParams
+          },
+          body
+        })
+      );
+    }
+    /**
+     * Get an address for a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with address details
+     */
+    async getAddress(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/customers/{user_id}/addresses/{address_id}", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * Update an address for a customer
+     *
+     * @param pathParams - Path parameters
+     * @param body - Address update body
+     * @returns Promise with address details
+     */
+    async updateAddress(pathParams, body) {
+      return this.executeRequest(
+        () => this.client.PUT("/customers/{user_id}/addresses/{address_id}", {
+          params: {
+            path: pathParams
+          },
+          body
+        })
+      );
+    }
+    /**
+     * Delete an address for a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with address details
+     */
+    async deleteAddress(pathParams) {
+      return this.executeRequest(
+        () => this.client.DELETE("/customers/{user_id}/addresses/{address_id}", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * Get customer loyalty details
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with loyalty details
+     */
+    async getLoyaltyDetails(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/customers/{user_id}/loyalty", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * List all loyalty points activity for a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with loyalty points activity
+     */
+    async listLoyaltyPointsActivity(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/customers/{user_id}/loyalty-points-activity", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+    /**
+     * List all reviews left by a customer
+     *
+     * @param pathParams - Path parameters
+     * @returns Promise with reviews
+     */
+    async listCustomerReviews(pathParams) {
+      return this.executeRequest(
+        () => this.client.GET("/customers/{user_id}/reviews", {
+          params: {
+            path: pathParams
+          }
+        })
+      );
+    }
+  };
+
+  // src/index.ts
+  var StorefrontSDK = class {
+    /**
+     * Client for catalog-related endpoints (products, categories, etc.)
+     */
+    catalog;
+    /**
+     * Client for cart-related endpoints
+     */
+    cart;
+    /**
+     * Client for authentication-related endpoints
+     */
+    auth;
+    /**
+     * Client for customer-related endpoints
+     */
+    customer;
+    /**
+     * Client for helper-related endpoints
+     */
+    helpers;
+    /**
+     * Client for shipping-related endpoints
+     */
+    shipping;
+    /**
+     * Client for order-related endpoints
+     */
+    order;
+    /**
+     * Create a new StorefrontSDK instance
+     *
+     * @param options - Configuration options for the SDK
+     */
+    constructor(options) {
+      const config = {
+        storeId: options.storeId,
+        environment: options.environment,
+        baseUrl: options.baseUrl,
+        accessToken: options.accessToken,
+        refreshToken: options.refreshToken,
+        apiKey: options.apiKey,
+        timeout: options.timeout,
+        tokenStorage: options.tokenStorage,
+        onTokensUpdated: options.onTokensUpdated,
+        onTokensCleared: options.onTokensCleared,
+        defaultHeaders: options.defaultHeaders,
+        debug: options.debug,
+        logger: options.logger
+      };
+      this.catalog = new CatalogClient(config);
+      this.cart = new CartClient(config);
+      this.auth = new AuthClient(config);
+      this.customer = new CustomerClient(config);
+      this.helpers = new HelpersClient(config);
+      this.shipping = new ShippingClient(config);
+      this.order = new OrderClient(config);
+    }
+    /**
+     * Set authentication tokens for all clients
+     *
+     * @param accessToken - The access token (required)
+     * @param refreshToken - The refresh token (optional)
+     *
+     * Behavior:
+     * - If tokenStorage is provided: Stores tokens for automatic management
+     * - If tokenStorage is not provided: Only stores access token for manual management
+     */
+    async setTokens(accessToken, refreshToken) {
+      await this.catalog.setTokens(accessToken, refreshToken);
+      await this.cart.setTokens(accessToken, refreshToken);
+      await this.auth.setTokens(accessToken, refreshToken);
+      await this.customer.setTokens(accessToken, refreshToken);
+      await this.helpers.setTokens(accessToken, refreshToken);
+      await this.shipping.setTokens(accessToken, refreshToken);
+      await this.order.setTokens(accessToken, refreshToken);
+    }
+    /**
+     * Clear all authentication tokens from all clients
+     *
+     * Behavior:
+     * - If tokenStorage is provided: Clears both access and refresh tokens from storage
+     * - If tokenStorage is not provided: Clears the manual access token
+     */
+    async clearTokens() {
+      await this.catalog.clearTokens();
+      await this.cart.clearTokens();
+      await this.auth.clearTokens();
+      await this.customer.clearTokens();
+      await this.helpers.clearTokens();
+      await this.shipping.clearTokens();
+      await this.order.clearTokens();
+    }
+    /**
+     * Set the API key for all clients
+     *
+     * @param apiKey - The API key to set
+     */
+    setApiKey(apiKey) {
+      this.catalog.setApiKey(apiKey);
+      this.cart.setApiKey(apiKey);
+      this.auth.setApiKey(apiKey);
+      this.customer.setApiKey(apiKey);
+      this.helpers.setApiKey(apiKey);
+      this.shipping.setApiKey(apiKey);
+      this.order.setApiKey(apiKey);
+    }
+    /**
+     * Clear the API key from all clients
+     */
+    clearApiKey() {
+      this.catalog.clearApiKey();
+      this.cart.clearApiKey();
+      this.auth.clearApiKey();
+      this.customer.clearApiKey();
+      this.helpers.clearApiKey();
+      this.shipping.clearApiKey();
+      this.order.clearApiKey();
+    }
+    /**
+     * Get the current access token if using token storage
+     */
+    async getAccessToken() {
+      return await this.auth.getAuthorizationHeader().then(
+        (header) => header.startsWith("Bearer ") ? header.substring(7) : null
+      );
+    }
+    /**
+     * Get user information from the current access token
+     *
+     * @returns User information extracted from JWT token, or null if no token or invalid token
+     */
+    async getUserInfo() {
+      const token = await this.getAccessToken();
+      if (!token) return null;
+      return extractUserInfoFromToken(token);
+    }
+    /**
+     * Get the current user ID from the access token
+     *
+     * @returns User ID (ulid) or null if no token or invalid token
+     */
+    async getUserId() {
+      const token = await this.getAccessToken();
+      if (!token) return null;
+      return getUserIdFromToken(token);
+    }
+    /**
+     * Check if the current user is logged in (not anonymous)
+     *
+     * @returns True if user is logged in, false if anonymous or no token
+     */
+    async isLoggedIn() {
+      const token = await this.getAccessToken();
+      if (!token) return false;
+      return isUserLoggedIn(token);
+    }
+    /**
+     * Check if the current user is anonymous
+     *
+     * @returns True if user is anonymous or no token, false if logged in
+     */
+    async isAnonymous() {
+      const token = await this.getAccessToken();
+      if (!token) return true;
+      return isUserAnonymous(token);
+    }
+    /**
+     * Get the customer ID from the current access token
+     *
+     * @returns Customer ID or null if no token, invalid token, or user has no customer ID
+     */
+    async getCustomerId() {
+      const userInfo = await this.getUserInfo();
+      return userInfo?.customerId || null;
+    }
+    /**
+     * Get the customer group ID from the current access token
+     *
+     * @returns Customer group ID or null if no token, invalid token, or user has no customer group
+     */
+    async getCustomerGroupId() {
+      const userInfo = await this.getUserInfo();
+      return userInfo?.customerGroupId || null;
+    }
+    /**
+     * Set default headers for all clients
+     *
+     * @param headers - Default headers to set (only supported headers allowed)
+     */
+    setDefaultHeaders(headers) {
+      const newConfig = { ...this.catalog["config"], defaultHeaders: headers };
+      this.catalog["config"] = newConfig;
+      this.cart["config"] = newConfig;
+      this.auth["config"] = newConfig;
+      this.customer["config"] = newConfig;
+      this.helpers["config"] = newConfig;
+      this.shipping["config"] = newConfig;
+      this.order["config"] = newConfig;
+    }
+    /**
+     * Get current default headers
+     *
+     * @returns Current default headers
+     */
+    getDefaultHeaders() {
+      return this.catalog["config"].defaultHeaders;
+    }
+  };
+  var index_default = StorefrontSDK;
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map