@commercengine/storefront-sdk 0.8.1 → 0.8.2

package/dist/index.cjs

@@ -1,3878 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-const openapi_fetch = __toESM(require("openapi-fetch"));
-const jose = __toESM(require("jose"));
-
-//#region src/lib/jwt-utils.ts
-/**
-* Decode and extract user information from a JWT token
-* 
-* @param token - The JWT token to decode
-* @returns User information or null if token is invalid
-*/
-function extractUserInfoFromToken(token) {
-	try {
-		const payload = (0, jose.decodeJwt)(token);
-		return {
-			id: payload.ulid,
-			email: payload.email,
-			phone: payload.phone,
-			username: payload.username,
-			firstName: payload.first_name,
-			lastName: payload.last_name,
-			storeId: payload.store_id,
-			isLoggedIn: payload.is_logged_in,
-			isAnonymous: !payload.is_logged_in,
-			customerId: payload.customer_id,
-			customerGroupId: payload.customer_group_id,
-			anonymousId: payload.anonymous_id,
-			tokenExpiry: /* @__PURE__ */ new Date(payload.exp * 1e3),
-			tokenIssuedAt: /* @__PURE__ */ new Date(payload.iat * 1e3)
-		};
-	} catch (error) {
-		console.warn("Failed to decode JWT token:", error);
-		return null;
-	}
-}
-/**
-* Check if a JWT token is expired
-* 
-* @param token - The JWT token to check
-* @param bufferSeconds - Buffer time in seconds (default: 30)
-* @returns True if token is expired or will expire within buffer time
-*/
-function isTokenExpired(token, bufferSeconds = 30) {
-	try {
-		const payload = (0, jose.decodeJwt)(token);
-		if (!payload.exp) return true;
-		const currentTime = Math.floor(Date.now() / 1e3);
-		const expiryTime = payload.exp;
-		return currentTime >= expiryTime - bufferSeconds;
-	} catch (error) {
-		console.warn("Failed to decode JWT token:", error);
-		return true;
-	}
-}
-/**
-* Get the user ID from a JWT token
-* 
-* @param token - The JWT token
-* @returns User ID (ulid) or null if token is invalid
-*/
-function getUserIdFromToken(token) {
-	const userInfo = extractUserInfoFromToken(token);
-	return userInfo?.id || null;
-}
-/**
-* Check if user is logged in based on JWT token
-* 
-* @param token - The JWT token
-* @returns True if user is logged in, false otherwise
-*/
-function isUserLoggedIn(token) {
-	const userInfo = extractUserInfoFromToken(token);
-	return userInfo?.isLoggedIn || false;
-}
-/**
-* Check if user is anonymous based on JWT token
-* 
-* @param token - The JWT token
-* @returns True if user is anonymous, false otherwise
-*/
-function isUserAnonymous(token) {
-	const userInfo = extractUserInfoFromToken(token);
-	return userInfo?.isAnonymous || true;
-}
-
-//#endregion
-//#region src/lib/auth-utils.ts
-/**
-* Extract pathname from URL
-*/
-function getPathnameFromUrl(url) {
-	try {
-		const urlObj = new URL(url);
-		return urlObj.pathname;
-	} catch {
-		return url.split("?")[0];
-	}
-}
-/**
-* Check if a URL path is an auth endpoint that should use API key
-*/
-function isAnonymousAuthEndpoint(pathname) {
-	return pathname.endsWith("/auth/anonymous");
-}
-/**
-* Check if a URL path is a login/register endpoint that returns tokens
-*/
-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));
-}
-/**
-* Check if a URL path is the logout endpoint
-*/
-function isLogoutEndpoint(pathname) {
-	return pathname.endsWith("/auth/logout");
-}
-
-//#endregion
-//#region src/lib/middleware.ts
-/**
-* Simple in-memory token storage implementation
-*/
-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;
-	}
-};
-/**
-* Browser localStorage token storage implementation
-*/
-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);
-		}
-	}
-};
-/**
-* Cookie-based token storage implementation
-*/
-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 || 10080 * 60,
-			path: options.path || "/",
-			domain: options.domain,
-			secure: options.secure ?? (typeof window !== "undefined" && window.location?.protocol === "https:"),
-			sameSite: options.sameSite || "Lax",
-			httpOnly: false
-		};
-	}
-	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;
-	}
-};
-/**
-* Create authentication middleware for openapi-fetch
-*/
-function createAuthMiddleware(config) {
-	let isRefreshing = false;
-	let refreshPromise = null;
-	let hasAssessedTokens = false;
-	const assessTokenStateOnce = async () => {
-		if (hasAssessedTokens) return;
-		hasAssessedTokens = true;
-		try {
-			const accessToken = await config.tokenStorage.getAccessToken();
-			const refreshToken = await config.tokenStorage.getRefreshToken();
-			if (!accessToken && refreshToken) {
-				await config.tokenStorage.clearTokens();
-				console.info("Cleaned up orphaned refresh token");
-			}
-		} catch (error) {
-			console.warn("Token state assessment failed:", error);
-		}
-	};
-	const refreshTokens = async () => {
-		if (isRefreshing && refreshPromise) return refreshPromise;
-		isRefreshing = true;
-		refreshPromise = (async () => {
-			try {
-				const refreshToken = await config.tokenStorage.getRefreshToken();
-				let newTokens;
-				if (refreshToken && !isTokenExpired(refreshToken)) if (config.refreshTokenFn) newTokens = await config.refreshTokenFn(refreshToken);
-				else {
-					const response = await fetch(`${config.baseUrl}/auth/refresh-token`, {
-						method: "POST",
-						headers: { "Content-Type": "application/json" },
-						body: JSON.stringify({ refresh_token: refreshToken })
-					});
-					if (!response.ok) throw new Error(`Token refresh failed: ${response.status}`);
-					const data = await response.json();
-					newTokens = data.content;
-				}
-				else {
-					const currentAccessToken = await config.tokenStorage.getAccessToken();
-					if (!currentAccessToken) throw new Error("No tokens available for refresh");
-					const reason = refreshToken ? "refresh token expired" : "no refresh token available";
-					const response = await fetch(`${config.baseUrl}/auth/anonymous`, {
-						method: "POST",
-						headers: {
-							"Content-Type": "application/json",
-							...config.apiKey && { "X-Api-Key": config.apiKey },
-							Authorization: `Bearer ${currentAccessToken}`
-						}
-					});
-					if (!response.ok) throw new Error(`Anonymous token fallback failed: ${response.status}`);
-					const data = await response.json();
-					newTokens = data.content;
-					console.info(`Token refreshed via anonymous fallback (${reason}) - user may need to re-authenticate for privileged operations`);
-				}
-				await config.tokenStorage.setAccessToken(newTokens.access_token);
-				await config.tokenStorage.setRefreshToken(newTokens.refresh_token);
-				config.onTokensUpdated?.(newTokens.access_token, newTokens.refresh_token);
-			} catch (error) {
-				console.error("Token refresh failed:", error);
-				await config.tokenStorage.clearTokens();
-				config.onTokensCleared?.();
-				throw error;
-			} finally {
-				isRefreshing = false;
-				refreshPromise = null;
-			}
-		})();
-		return refreshPromise;
-	};
-	return {
-		async onRequest({ request }) {
-			const pathname = getPathnameFromUrl(request.url);
-			await assessTokenStateOnce();
-			if (isAnonymousAuthEndpoint(pathname)) {
-				if (config.apiKey) request.headers.set("X-Api-Key", config.apiKey);
-				const existingToken = await config.tokenStorage.getAccessToken();
-				if (existingToken && !isTokenExpired(existingToken) && isUserLoggedIn(existingToken)) return new Response(JSON.stringify({
-					message: "Cannot create anonymous session while authenticated",
-					success: false,
-					code: "USER_ALREADY_AUTHENTICATED"
-				}), {
-					status: 400,
-					headers: { "Content-Type": "application/json" }
-				});
-				if (existingToken) request.headers.set("Authorization", `Bearer ${existingToken}`);
-				return request;
-			}
-			let accessToken = await config.tokenStorage.getAccessToken();
-			if (!accessToken) try {
-				const response = await fetch(`${config.baseUrl}/auth/anonymous`, {
-					method: "POST",
-					headers: {
-						"Content-Type": "application/json",
-						...config.apiKey && { "X-Api-Key": config.apiKey }
-					}
-				});
-				if (response.ok) {
-					const data = await response.json();
-					const tokens = data.content;
-					if (tokens?.access_token && tokens?.refresh_token) {
-						await config.tokenStorage.setAccessToken(tokens.access_token);
-						await config.tokenStorage.setRefreshToken(tokens.refresh_token);
-						accessToken = tokens.access_token;
-						config.onTokensUpdated?.(tokens.access_token, tokens.refresh_token);
-						console.info("Automatically created anonymous session for first API request");
-					}
-				}
-			} catch (error) {
-				console.warn("Failed to automatically create anonymous tokens:", error);
-			}
-			if (accessToken && isTokenExpired(accessToken)) try {
-				await refreshTokens();
-				accessToken = await config.tokenStorage.getAccessToken();
-			} catch (error) {}
-			if (accessToken) request.headers.set("Authorization", `Bearer ${accessToken}`);
-			return request;
-		},
-		async onResponse({ request, response }) {
-			const pathname = getPathnameFromUrl(request.url);
-			if (response.ok) {
-				if (isTokenReturningEndpoint(pathname) || isAnonymousAuthEndpoint(pathname)) try {
-					const data = await response.clone().json();
-					const content = data.content;
-					if (content?.access_token && content?.refresh_token) {
-						await config.tokenStorage.setAccessToken(content.access_token);
-						await config.tokenStorage.setRefreshToken(content.refresh_token);
-						config.onTokensUpdated?.(content.access_token, content.refresh_token);
-					}
-				} catch (error) {
-					console.warn("Failed to extract tokens from response:", error);
-				}
-				else if (isLogoutEndpoint(pathname)) {
-					await config.tokenStorage.clearTokens();
-					config.onTokensCleared?.();
-				}
-			}
-			if (response.status === 401 && !isAnonymousAuthEndpoint(pathname)) {
-				const currentToken = await config.tokenStorage.getAccessToken();
-				if (currentToken && isTokenExpired(currentToken, 0)) try {
-					await refreshTokens();
-					const newToken = await config.tokenStorage.getAccessToken();
-					if (newToken) {
-						const retryRequest = request.clone();
-						retryRequest.headers.set("Authorization", `Bearer ${newToken}`);
-						return fetch(retryRequest);
-					}
-				} catch (error) {
-					console.warn("Token refresh failed on 401 response:", error);
-				}
-			}
-			return response;
-		}
-	};
-}
-/**
-* Helper function to create auth middleware with sensible defaults
-*/
-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
-	});
-}
-
-//#endregion
-//#region src/lib/logger-utils.ts
-/**
-* Response utilities for debugging and working with Response objects
-*/
-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}`;
-	}
-};
-/**
-* Debug logging utilities
-*/
-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();
-	}
-};
-/**
-* Extract request body for logging
-*/
-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]";
-	}
-}
-/**
-* Create debug middleware for openapi-fetch (internal use)
-*/
-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;
-		}
-	};
-}
-
-//#endregion
-//#region src/lib/header-utils.ts
-/**
-* Mapping of SDK header parameter names to actual HTTP header names
-* Only include headers that need transformation - others pass through as-is
-*/
-const HEADER_TRANSFORMATIONS = { customer_group_id: "x-customer-group-id" };
-/**
-* Transform SDK header parameters to actual HTTP header names
-* Headers not in the transformation map are passed through unchanged
-*
-* @param headers - Headers object with SDK parameter names
-* @returns Headers object with actual HTTP header names
-*/
-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;
-}
-/**
-* Merge default headers with method-level headers
-* Method-level headers take precedence over default headers
-* Automatically transforms SDK parameter names to HTTP header names
-*
-* @param defaultHeaders - Default headers from SDK configuration
-* @param methodHeaders - Headers passed to the specific method call
-* @returns Merged headers object with proper HTTP header names
-*/
-function mergeHeaders(defaultHeaders, methodHeaders) {
-	const merged = {};
-	if (defaultHeaders) {
-		const transformedDefaults = transformHeaders(defaultHeaders);
-		Object.assign(merged, transformedDefaults);
-	}
-	if (methodHeaders) Object.assign(merged, methodHeaders);
-	Object.keys(merged).forEach((key) => {
-		if (merged[key] === void 0) delete merged[key];
-	});
-	return merged;
-}
-
-//#endregion
-//#region src/lib/client.ts
-/**
-* Available API environments
-*/
-let Environment = /* @__PURE__ */ function(Environment$1) {
-	/**
-	* Staging environment
-	*/
-	Environment$1["Staging"] = "staging";
-	/**
-	* Production environment
-	*/
-	Environment$1["Production"] = "production";
-	return Environment$1;
-}({});
-/**
-* Base API client for Storefront API
-*/
-var StorefrontAPIClient = class {
-	client;
-	config;
-	baseUrl;
-	initializationPromise = null;
-	/**
-	* Create a new StorefrontAPIClient
-	*
-	* @param config - Configuration for the API client
-	*/
-	constructor(config) {
-		this.config = { ...config };
-		this.baseUrl = this.getBaseUrlFromConfig(this.config);
-		this.client = (0, openapi_fetch.default)({ baseUrl: this.baseUrl });
-		if (this.config.tokenStorage) {
-			const authMiddleware = createDefaultAuthMiddleware({
-				apiKey: this.config.apiKey,
-				baseUrl: this.baseUrl,
-				tokenStorage: this.config.tokenStorage,
-				onTokensUpdated: this.config.onTokensUpdated,
-				onTokensCleared: this.config.onTokensCleared
-			});
-			this.client.use(authMiddleware);
-			if (this.config.accessToken) {
-				this.initializationPromise = this.initializeTokens(this.config.accessToken, this.config.refreshToken);
-				this.config.accessToken = void 0;
-				this.config.refreshToken = void 0;
-			}
-		} else this.client.use({ onRequest: async ({ request }) => {
-			const pathname = getPathnameFromUrl(request.url);
-			if (isAnonymousAuthEndpoint(pathname)) {
-				if (this.config.apiKey) request.headers.set("X-Api-Key", this.config.apiKey);
-				if (this.config.accessToken) request.headers.set("Authorization", `Bearer ${this.config.accessToken}`);
-				return request;
-			}
-			if (this.config.accessToken) request.headers.set("Authorization", `Bearer ${this.config.accessToken}`);
-			return request;
-		} });
-		if (this.config.timeout) this.setupTimeoutMiddleware();
-		if (this.config.debug) {
-			const debugMiddleware = createDebugMiddleware(this.config.logger);
-			this.client.use(debugMiddleware);
-		}
-	}
-	/**
-	* Set up timeout middleware
-	*/
-	setupTimeoutMiddleware() {
-		this.client.use({ onRequest: async ({ request }) => {
-			const controller = new AbortController();
-			const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
-			if (request.signal) request.signal.addEventListener("abort", () => controller.abort());
-			const newRequest = new Request(request, { signal: controller.signal });
-			controller.signal.addEventListener("abort", () => clearTimeout(timeoutId));
-			return newRequest;
-		} });
-	}
-	/**
-	* Constructs the base URL from the configuration
-	*
-	* @param config - The client configuration
-	* @returns The constructed base URL
-	*/
-	getBaseUrlFromConfig(config) {
-		if (config.baseUrl) return config.baseUrl;
-		const env = config.environment || Environment.Production;
-		switch (env) {
-			case Environment.Staging: return `https://staging.api.commercengine.io/api/v1/${config.storeId}/storefront`;
-			case Environment.Production:
-			default: return `https://prod.api.commercengine.io/api/v1/${config.storeId}/storefront`;
-		}
-	}
-	/**
-	* Get the base URL of the API
-	*
-	* @returns The base URL of the API
-	*/
-	getBaseUrl() {
-		return this.baseUrl;
-	}
-	/**
-	* Get the authorization header value
-	* If using token storage, gets the current token from storage
-	* Otherwise returns the manual token
-	*
-	* @returns The Authorization header value or empty string if no token is set
-	*/
-	async getAuthorizationHeader() {
-		if (this.config.tokenStorage && this.initializationPromise) await this.initializationPromise;
-		if (this.config.tokenStorage) {
-			const token = await this.config.tokenStorage.getAccessToken();
-			return token ? `Bearer ${token}` : "";
-		}
-		return this.config.accessToken ? `Bearer ${this.config.accessToken}` : "";
-	}
-	/**
-	* Set authentication tokens
-	*
-	* @param accessToken - The access token (required)
-	* @param refreshToken - The refresh token (optional)
-	*
-	* Behavior:
-	* - If tokenStorage is provided: Stores tokens for automatic management
-	* - If tokenStorage is not provided: Only stores access token for manual management
-	*/
-	async setTokens(accessToken, refreshToken) {
-		if (this.config.tokenStorage) {
-			await this.config.tokenStorage.setAccessToken(accessToken);
-			if (refreshToken) await this.config.tokenStorage.setRefreshToken(refreshToken);
-		} else {
-			this.config.accessToken = accessToken;
-			if (refreshToken) console.warn("Refresh token provided but ignored in manual token management mode. Use tokenStorage for automatic management.");
-		}
-	}
-	/**
-	* Clear all authentication tokens
-	*
-	* Behavior:
-	* - If tokenStorage is provided: Clears both access and refresh tokens from storage
-	* - If tokenStorage is not provided: Clears the manual access token
-	*/
-	async clearTokens() {
-		if (this.config.tokenStorage) await this.config.tokenStorage.clearTokens();
-		else this.config.accessToken = void 0;
-	}
-	/**
-	* Set the X-Api-Key header
-	*
-	* @param apiKey - The API key to set
-	*/
-	setApiKey(apiKey) {
-		this.config.apiKey = apiKey;
-	}
-	/**
-	* Clear the X-Api-Key header
-	*/
-	clearApiKey() {
-		this.config.apiKey = void 0;
-	}
-	/**
-	* Execute a request and handle the response
-	*
-	* @param apiCall - Function that executes the API request
-	* @returns Promise with the API response
-	*/
-	async executeRequest(apiCall) {
-		try {
-			const { data, error, response } = await apiCall();
-			if (error) return {
-				data: null,
-				error,
-				response
-			};
-			if (data && data.content !== void 0) return {
-				data: data.content,
-				error: null,
-				response
-			};
-			return {
-				data,
-				error: null,
-				response
-			};
-		} catch (err) {
-			const mockResponse = new Response(null, {
-				status: 0,
-				statusText: "Network Error"
-			});
-			const errorResult = {
-				data: null,
-				error: {
-					success: false,
-					code: "NETWORK_ERROR",
-					message: "Network error occurred",
-					error: err
-				},
-				response: mockResponse
-			};
-			return errorResult;
-		}
-	}
-	/**
-	* Initialize tokens in storage (private helper method)
-	*/
-	async initializeTokens(accessToken, refreshToken) {
-		try {
-			if (this.config.tokenStorage) {
-				await this.config.tokenStorage.setAccessToken(accessToken);
-				if (refreshToken) await this.config.tokenStorage.setRefreshToken(refreshToken);
-			}
-		} catch (error) {
-			console.warn("Failed to initialize tokens in storage:", error);
-		}
-	}
-	/**
-	* Merge default headers with method-level headers
-	* Method-level headers take precedence over default headers
-	*
-	* @param methodHeaders - Headers passed to the specific method call
-	* @returns Merged headers object with proper HTTP header names
-	*/
-	mergeHeaders(methodHeaders) {
-		return mergeHeaders(this.config.defaultHeaders, methodHeaders);
-	}
-};
-
-//#endregion
-//#region src/lib/catalog.ts
-/**
-* Client for interacting with catalog endpoints
-*/
-var CatalogClient = class extends StorefrontAPIClient {
-	/**
-	* List all products
-	*
-	* @param options - Optional query parameters
-	* @param headers - Optional header parameters (customer_group_id, etc.)
-	* @returns Promise with products and pagination info
-	*
-	* @example
-	* ```typescript
-	* // Basic product listing
-	* const { data, error } = await sdk.catalog.listProducts();
-	*
-	* if (error) {
-	*   console.error("Failed to list products:", error);
-	*   return;
-	* }
-	*
-	* console.log("Products found:", data.products?.length || 0);
-	* console.log("Pagination:", data.pagination);
-	*
-	* // With filtering and pagination
-	* const { data: filteredData, error: filteredError } = await sdk.catalog.listProducts({
-	*   page: 1,
-	*   limit: 20,
-	*   sort_by: JSON.stringify({ "created_at": "desc" }),
-	*   category_slug: ["electronics", "smartphones"]
-	* });
-	*
-	* // Override customer group ID for this specific request
-	* const { data: overrideData, error: overrideError } = await sdk.catalog.listProducts(
-	*   {
-	*     page: 1,
-	*     limit: 20,
-	*     sort_by: JSON.stringify({ "created_at": "desc" }),
-	*     category_slug: ["electronics", "smartphones"]
-	*   },
-	*   {
-	*     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
-	*   }
-	* );
-	*
-	* if (filteredError) {
-	*   console.error("Failed to get filtered products:", filteredError);
-	*   return;
-	* }
-	*
-	* filteredData.products?.forEach(product => {
-	*   console.log(`Product: ${product.name} - ${product.price}`);
-	* });
-	* ```
-	*/
-	async listProducts(options, headers) {
-		const mergedHeaders = this.mergeHeaders(headers);
-		return this.executeRequest(() => this.client.GET("/catalog/products", { params: {
-			query: options,
-			header: mergedHeaders
-		} }));
-	}
-	/**
-	* List all skus
-	*
-	* @param options - Optional query parameters
-	* @param headers - Optional header parameters (customer_group_id, etc.)
-	* @returns Promise with skus and pagination info
-	*
-	* @example
-	* ```typescript
-	* // Basic SKU listing
-	* const { data, error } = await sdk.catalog.listSkus();
-	*
-	* if (error) {
-	*   console.error("Failed to list SKUs:", error);
-	*   return;
-	* }
-	*
-	* console.log("SKUs found:", data.skus?.length || 0);
-	* console.log("Pagination:", data.pagination);
-	*
-	* // With pagination
-	* const { data: skuData, error: skuError } = await sdk.catalog.listSkus({
-	*   page: 1,
-	*   limit: 50
-	* });
-	*
-	* // Override customer group ID for this specific request
-	* const { data: overrideData, error: overrideError } = await sdk.catalog.listSkus(
-	*   {
-	*     page: 1,
-	*     limit: 50
-	*   },
-	*   {
-	*     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
-	*   }
-	* );
-	*
-	* if (skuError) {
-	*   console.error("Failed to get SKUs:", skuError);
-	*   return;
-	* }
-	*
-	* skuData.skus?.forEach(sku => {
-	*   console.log(`SKU: ${sku.sku} - Price: ${sku.price}`);
-	* });
-	* ```
-	*/
-	async listSkus(options, headers) {
-		const mergedHeaders = this.mergeHeaders(headers);
-		return this.executeRequest(() => this.client.GET("/catalog/skus", { params: {
-			query: options,
-			header: mergedHeaders
-		} }));
-	}
-	/**
-	* Get details for a specific product
-	*
-	* @param pathParams - The path parameters (product ID or slug)
-	* @param headers - Optional header parameters (customer_group_id, etc.)
-	* @returns Promise with product details
-	*
-	* @example
-	* ```typescript
-	* // Get product by ID
-	* const { data, error } = await sdk.catalog.getProductDetail(
-	*   { product_id_or_slug: "prod_123" }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to get product details:", error);
-	*   return;
-	* }
-	*
-	* console.log("Product:", data.product.name);
-	* console.log("Price:", data.product.price);
-	* console.log("Description:", data.product.description);
-	*
-	* // Get product by slug
-	* const { data: slugData, error: slugError } = await sdk.catalog.getProductDetail({
-	*   product_id_or_slug: "detox-candy"
-	* });
-	*
-	* // Override customer group ID for this specific request
-	* const { data: overrideData, error: overrideError } = await sdk.catalog.getProductDetail(
-	*   { product_id_or_slug: "detox-candy" },
-	*   {
-	*     "x-customer-group-id": "premium_customers" // Override default SDK config
-	*   }
-	* );
-	*
-	* if (slugError) {
-	*   console.error("Failed to get product by slug:", slugError);
-	*   return;
-	* }
-	*
-	* console.log("Product with custom pricing:", slugData.product.price);
-	* ```
-	*/
-	async getProductDetail(pathParams, headers) {
-		const mergedHeaders = this.mergeHeaders(headers);
-		return this.executeRequest(() => this.client.GET("/catalog/products/{product_id_or_slug}", { params: {
-			path: pathParams,
-			header: mergedHeaders
-		} }));
-	}
-	/**
-	* List all variants for a specific product
-	*
-	* @param pathParams - The path parameters (product ID)
-	* @param headers - Optional header parameters (customer_group_id, etc.)
-	* @returns Promise with product variants and pagination info
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.catalog.listProductVariants(
-	*   { product_id: "prod_123" }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to list product variants:", error);
-	*   return;
-	* }
-	*
-	* console.log("Variants found:", data.variants?.length || 0);
-	*
-	* data.variants?.forEach(variant => {
-	*   console.log(`Variant: ${variant.name} - SKU: ${variant.sku} - Price: ${variant.price}`);
-	* });
-	*
-	* // Override customer group ID for this specific request
-	* const { data: overrideData, error: overrideError } = await sdk.catalog.listProductVariants(
-	*   { product_id: "prod_123" },
-	*   {
-	*     "x-customer-group-id": "wholesale_customers" // Override default SDK config
-	*   }
-	* );
-	* ```
-	*/
-	async listProductVariants(pathParams, headers) {
-		const mergedHeaders = this.mergeHeaders(headers);
-		return this.executeRequest(() => this.client.GET("/catalog/products/{product_id}/variants", { params: {
-			path: pathParams,
-			header: mergedHeaders
-		} }));
-	}
-	/**
-	* Get details for a specific product variant
-	*
-	* @param pathParams - The path parameters (product ID and variant ID)
-	* @param headers - Optional header parameters (customer_group_id, etc.)
-	* @returns Promise with variant details
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.catalog.getVariantDetail(
-	*   {
-	*     product_id: "prod_123",
-	*     variant_id: "var_456"
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to get variant details:", error);
-	*   return;
-	* }
-	*
-	* console.log("Variant:", data.variant.name);
-	* console.log("SKU:", data.variant.sku);
-	* console.log("Price:", data.variant.price);
-	* console.log("Stock:", data.variant.stock);
-	* ```
-	*/
-	async getVariantDetail(pathParams, headers) {
-		const mergedHeaders = this.mergeHeaders(headers);
-		return this.executeRequest(() => this.client.GET("/catalog/products/{product_id}/variants/{variant_id}", { params: {
-			path: pathParams,
-			header: mergedHeaders
-		} }));
-	}
-	/**
-	* List all product categories
-	*
-	* @param options - Optional query parameters
-	* @returns Promise with categories and pagination info
-	*
-	* @example
-	* ```typescript
-	* // Basic category listing
-	* const { data, error } = await sdk.catalog.listCategories();
-	*
-	* if (error) {
-	*   console.error("Failed to list categories:", error);
-	*   return;
-	* }
-	*
-	* console.log("Categories found:", data.categories?.length || 0);
-	*
-	* data.categories?.forEach(category => {
-	*   console.log(`Category: ${category.name} - ${category.description}`);
-	* });
-	*
-	* // With pagination
-	* const { data: catData, error: catError } = await sdk.catalog.listCategories({
-	*   page: 1,
-	*   limit: 10
-	* });
-	* ```
-	*/
-	async listCategories(options) {
-		return this.executeRequest(() => this.client.GET("/catalog/categories", { params: { query: options } }));
-	}
-	/**
-	* List all reviews for a specific product
-	*
-	* @param pathParams - The path parameters (product ID)
-	* @param queryParams - Optional query parameters
-	* @returns Promise with product reviews and pagination info
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.catalog.listProductReviews(
-	*   { product_id: "prod_123" }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to list product reviews:", error);
-	*   return;
-	* }
-	*
-	* console.log("Reviews found:", data.reviews?.length || 0);
-	*
-	* data.reviews?.forEach(review => {
-	*   console.log(`Review by ${review.customer_name}: ${review.rating}/5`);
-	*   console.log("Comment:", review.comment);
-	* });
-	*
-	* // With pagination
-	* const { data: reviewData, error: reviewError } = await sdk.catalog.listProductReviews(
-	*   { product_id: "prod_123" },
-	*   {
-	*     page: 1,
-	*     limit: 5
-	*   }
-	* );
-	* ```
-	*/
-	async listProductReviews(pathParams, queryParams) {
-		return this.executeRequest(() => this.client.GET("/catalog/products/{product_id}/reviews", { params: {
-			path: pathParams,
-			query: queryParams
-		} }));
-	}
-	/**
-	* Create a product review
-	*
-	* @param pathParams - The path parameters (product ID)
-	* @param formData - The review data including rating, comment, and optional images
-	* @returns Promise with review creation response
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.catalog.createProductReview(
-	*   { product_id: "prod_123" },
-	*   {
-	*     rating: 5,
-	*     comment: "Excellent product! Highly recommended.",
-	*     images: [
-	*       new File(["image data"], "review1.jpg", { type: "image/jpeg" }),
-	*       new File(["image data"], "review2.jpg", { type: "image/jpeg" })
-	*     ]
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to create review:", error);
-	*   return;
-	* }
-	*
-	* console.log("Review created successfully:", data.message);
-	* ```
-	*/
-	async createProductReview(pathParams, formData) {
-		return this.executeRequest(() => this.client.POST("/catalog/products/{product_id}/reviews", {
-			params: { path: pathParams },
-			body: formData,
-			bodySerializer: (body) => {
-				const fd = new FormData();
-				for (const [key, value] of Object.entries(body)) if (value !== void 0 && value !== null) if (value instanceof File || value instanceof Blob) fd.append(key, value);
-				else fd.append(key, String(value));
-				return fd;
-			}
-		}));
-	}
-	/**
-	* Search for products
-	*
-	* @param searchData - The search query and filters
-	* @param headers - Optional header parameters (customer_group_id, etc.)
-	* @returns Promise with search results including products, facets, and pagination
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.catalog.searchProducts({
-	*   query: "smartphone",
-	*   filters: {
-	*     category: ["electronics", "mobile"],
-	*     price_range: { min: 100, max: 1000 },
-	*     brand: ["Apple", "Samsung"] // facet names depend on product configuration
-	*   },
-	*   page: 1,
-	*   limit: 20
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to search products:", error);
-	*   return;
-	* }
-	*
-	* console.log("Search results:", data.skus?.length || 0, "products found");
-	* console.log("Facet distribution:", data.facet_distribution);
-	* console.log("Price range:", data.facet_stats.price_range);
-	*
-	* data.skus?.forEach(sku => {
-	*   console.log(`Found: ${sku.name} - ${sku.price}`);
-	* });
-	*
-	* // Override customer group ID for this specific request
-	* const { data: overrideData, error: overrideError } = await sdk.catalog.searchProducts(
-	*   {
-	*     query: "laptop",
-	*     filters: { category: ["computers"] }
-	*   },
-	*   {
-	*     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
-	*   }
-	* );
-	* ```
-	*/
-	async searchProducts(searchData, headers) {
-		const mergedHeaders = this.mergeHeaders(headers);
-		return this.executeRequest(() => this.client.POST("/catalog/products/search", {
-			params: { header: mergedHeaders },
-			body: searchData
-		}));
-	}
-	/**
-	* List cross-sell products
-	*
-	* @param options - Optional query parameters for filtering and pagination
-	* @param headers - Optional header parameters (customer_group_id, etc.)
-	* @returns Promise with cross-sell products
-	* @example
-	* ```typescript
-	* // Basic usage - get cross-sell products for cart items
-	* const { data, error } = await sdk.catalog.listCrossSellProducts({
-	*   product_id: ["prod_01H9XYZ12345ABCDE", "prod_01H9ABC67890FGHIJ"]
-	* });
-	*
-	* // Advanced usage with pagination and custom sorting
-	* const { data, error } = await sdk.catalog.listCrossSellProducts({
-	*   product_id: ["prod_01H9XYZ12345ABCDE"],
-	*   page: 1,
-	*   limit: 10,
-	*   sort_by: '{"price":"asc"}'
-	* });
-	*
-	* // Override customer group ID for this specific request
-	* const { data, error } = await sdk.catalog.listCrossSellProducts(
-	*   {
-	*     product_id: ["prod_01H9XYZ12345ABCDE"],
-	*     page: 1,
-	*     limit: 10
-	*   },
-	*   {
-	*     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to get cross-sell products:", error.message);
-	* } else {
-	*   console.log("Cross-sell products found:", data.content.products.length);
-	*   console.log("Pagination:", data.content.pagination);
-	*
-	*   data.content.products.forEach(product => {
-	*     console.log(`Product: ${product.name} - ${product.price}`);
-	*   });
-	* }
-	* ```
-	*/
-	async listCrossSellProducts(options, headers) {
-		const mergedHeaders = this.mergeHeaders(headers);
-		return this.executeRequest(() => this.client.GET("/catalog/products/cross-sell", { params: {
-			query: options,
-			header: mergedHeaders
-		} }));
-	}
-	/**
-	* List up-sell products
-	*
-	* @param options - Optional query parameters for filtering and pagination
-	* @param headers - Optional header parameters (customer_group_id, etc.)
-	* @returns Promise with up-sell products
-	* @example
-	* ```typescript
-	* // Basic usage - get up-sell products for cart items
-	* const { data, error } = await sdk.catalog.listUpSellProducts({
-	*   product_id: ["prod_01H9XYZ12345ABCDE"]
-	* });
-	*
-	* // Advanced usage with pagination and custom sorting
-	* const { data, error } = await sdk.catalog.listUpSellProducts({
-	*   product_id: ["prod_01H9XYZ12345ABCDE"],
-	*   page: 1,
-	*   limit: 15,
-	*   sort_by: '{"relevance":"desc"}'
-	* });
-	*
-	* // Override customer group ID for this specific request
-	* const { data, error } = await sdk.catalog.listUpSellProducts(
-	*   {
-	*     product_id: ["prod_01H9XYZ12345ABCDE"],
-	*     page: 1,
-	*     limit: 15
-	*   },
-	*   {
-	*     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to get up-sell products:", error.message);
-	* } else {
-	*   console.log("Up-sell products found:", data.content.products.length);
-	*   console.log("Pagination:", data.content.pagination);
-	*
-	*   data.content.products.forEach(product => {
-	*     console.log(`Up-sell: ${product.name} - ${product.price}`);
-	*   });
-	* }
-	* ```
-	*/
-	async listUpSellProducts(options, headers) {
-		const mergedHeaders = this.mergeHeaders(headers);
-		return this.executeRequest(() => this.client.GET("/catalog/products/up-sell", { params: {
-			query: options,
-			header: mergedHeaders
-		} }));
-	}
-	/**
-	* List similar products
-	*
-	* @param options - Optional query parameters for filtering and pagination
-	* @param headers - Optional header parameters (customer_group_id, etc.)
-	* @returns Promise with similar products
-	* @example
-	* ```typescript
-	* // Basic usage - get similar products for a specific product
-	* const { data, error } = await sdk.catalog.listSimilarProducts({
-	*   product_id: ["prod_01H9XYZ12345ABCDE"]
-	* });
-	*
-	* // Advanced usage with pagination and custom sorting
-	* const { data, error } = await sdk.catalog.listSimilarProducts({
-	*   product_id: ["prod_01H9XYZ12345ABCDE"],
-	*   page: 1,
-	*   limit: 20,
-	*     sort_by: '{"relevance":"desc"}'
-	* });
-	*
-	* // Override customer group ID for this specific request
-	* const { data, error } = await sdk.catalog.listSimilarProducts(
-	*   {
-	*     product_id: ["prod_01H9XYZ12345ABCDE"],
-	*     page: 1,
-	*     limit: 20
-	*   },
-	*   {
-	*     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to get similar products:", error.message);
-	* } else {
-	*   console.log("Similar products found:", data.content.products.length);
-	*   console.log("Pagination:", data.content.pagination);
-	*
-	*   data.content.products.forEach(product => {
-	*     console.log(`Similar: ${product.name} - ${product.price}`);
-	*   });
-	* }
-	* ```
-	*/
-	async listSimilarProducts(options, headers) {
-		const mergedHeaders = this.mergeHeaders(headers);
-		return this.executeRequest(() => this.client.GET("/catalog/products/similar", { params: {
-			query: options,
-			header: mergedHeaders
-		} }));
-	}
-};
-
-//#endregion
-//#region src/lib/cart.ts
-/**
-* Client for interacting with cart endpoints
-*/
-var CartClient = class extends StorefrontAPIClient {
-	/**
-	* Create a new cart
-	*
-	* @param payload - Object containing the items to add to the cart
-	* @returns Promise with the created cart
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.createCart({
-	*   items: [
-	*     {
-	*       product_id: "01H9XYZ12345ABCDE",
-	*       variant_id: null,
-	*       quantity: 2
-	*     },
-	*     {
-	*       product_id: "01H9ABC67890FGHIJ",
-	*       variant_id: "01H9XYZ67890KLMNO",
-	*       quantity: 1
-	*     }
-	*   ],
-	*   metadata: {
-	*     "source": "web",
-	*     "campaign": "summer_sale"
-	*   }
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to create cart:", error.message);
-	* } else {
-	*   console.log("Cart created:", data.cart.id);
-	* }
-	* ```
-	*/
-	async createCart(payload) {
-		return this.executeRequest(() => this.client.POST("/carts", { body: payload }));
-	}
-	/**
-	* Get cart details - either by ID or using the stored cart ID
-	*
-	* @param cartId - The ID of the cart
-	* @returns Promise with cart details
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.getCart({
-	*   id: "01H9CART12345ABCDE"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get cart:", error.message);
-	* } else {
-	*   const cart = data.cart;
-	*   console.log("Cart total:", cart.total_amount);
-	*   console.log("Items count:", cart.items.length);
-	* }
-	* ```
-	*/
-	async getCart(cartId) {
-		return this.executeRequest(() => this.client.GET("/carts/{id}", { params: { path: cartId } }));
-	}
-	/**
-	* Delete a cart - either by ID or using the stored cart ID
-	*
-	* @param cartId - The ID of the cart
-	* @returns Promise that resolves when the cart is deleted
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.deleteCart({
-	*   id: "01H9CART12345ABCDE"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to delete cart:", error.message);
-	* } else {
-	*   console.log("Cart deleted:", data.message);
-	* }
-	* ```
-	*/
-	async deleteCart(cartId) {
-		return this.executeRequest(() => this.client.DELETE("/carts/{id}", { params: { path: cartId } }));
-	}
-	/**
-	* Update cart items (add, update quantity, remove)
-	*
-	* @param cartId - The cart id
-	* @param body - The body of the request
-	* @returns Promise with updated cart
-	* @example
-	* ```typescript
-	* // Add item to cart
-	* const { data, error } = await sdk.cart.addDeleteCartItem(
-	*   { id: "01H9CART12345ABCDE" },
-	*   {
-	*     product_id: "01H9XYZ12345ABCDE",
-	*     variant_id: null,
-	*     quantity: 3
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to update cart:", error.message);
-	* } else {
-	*   console.log("Cart updated:", data.cart.items.length);
-	* }
-	*
-	* // Remove item from cart (set quantity to 0)
-	* const { data: removeData, error: removeError } = await sdk.cart.addDeleteCartItem(
-	*   { id: "01H9CART12345ABCDE" },
-	*   {
-	*     product_id: "01H9XYZ12345ABCDE",
-	*     variant_id: null,
-	*     quantity: 0
-	*   }
-	* );
-	* ```
-	*/
-	async addDeleteCartItem(cartId, body) {
-		return this.executeRequest(() => this.client.POST("/carts/{id}/items", {
-			params: { path: cartId },
-			body
-		}));
-	}
-	/**
-	* Get cart details by user ID
-	*
-	* @param userId - The ID of the user
-	* @returns Promise with cart details
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.getUserCart({
-	*   user_id: "01H9USER12345ABCDE"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get user cart:", error.message);
-	* } else {
-	*   console.log("User cart ID:", data.cart.id);
-	*   console.log("Cart value:", data.cart.subtotal_amount);
-	* }
-	* ```
-	*/
-	async getUserCart(userId) {
-		return this.executeRequest(() => this.client.GET("/carts/users/{user_id}", { params: { path: userId } }));
-	}
-	/**
-	* Delete a cart by user ID
-	*
-	* @param userId - The ID of the user
-	* @returns Promise that resolves when the cart is deleted
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.deleteUserCart({
-	*   user_id: "01H9USER12345ABCDE"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to delete user cart:", error.message);
-	* } else {
-	*   console.log("User cart cleared:", data.message);
-	* }
-	* ```
-	*/
-	async deleteUserCart(userId) {
-		return this.executeRequest(() => this.client.DELETE("/carts/users/{user_id}", {
-			params: { path: userId },
-			body: void 0
-		}));
-	}
-	/**
-	* Update cart addresses
-	*
-	* @param cartId - The ID of the cart
-	* @param addressData - The address data
-	* @returns Promise with updated cart
-	* @example
-	* ```typescript
-	* // For registered users with saved addresses
-	* const { data, error } = await sdk.cart.updateCartAddress(
-	*   { id: "01H9CART12345ABCDE" },
-	*   {
-	*     billing_address_id: "01H9ADDR12345BILL",
-	*     shipping_address_id: "01H9ADDR12345SHIP"
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to update cart address:", error.message);
-	* } else {
-	*   console.log("Addresses updated:", data.message);
-	* }
-	*
-	* // For guest checkout with new addresses
-	* const { data: guestData, error: guestError } = await sdk.cart.updateCartAddress(
-	*   { id: "01H9CART12345ABCDE" },
-	*   {
-	*     billing_address: {
-	*       first_name: "John",
-	*       last_name: "Doe",
-	*       email: "john@example.com",
-	*       phone: "9876543210",
-	*       country_code: "+91",
-	*       address_line1: "123 Main Street",
-	*       address_line2: "Apt 4B",
-	*       city: "Mumbai",
-	*       state: "Maharashtra",
-	*       pincode: "400001",
-	*       country: "India",
-	*       landmark: "Near Station",
-	*       tax_identification_number: null,
-	*       business_name: null
-	*     },
-	*     shipping_address: {
-	*       first_name: "John",
-	*       last_name: "Doe",
-	*       email: "john@example.com",
-	*       phone: "9876543210",
-	*       country_code: "+91",
-	*       address_line1: "456 Oak Avenue",
-	*       address_line2: null,
-	*       city: "Pune",
-	*       state: "Maharashtra",
-	*       pincode: "411001",
-	*       country: "India",
-	*       landmark: "Near Mall",
-	*       tax_identification_number: null,
-	*       business_name: null
-	*     }
-	*   }
-	* );
-	* ```
-	*/
-	async updateCartAddress(cartId, addressData) {
-		return this.executeRequest(() => this.client.POST("/carts/{id}/address", {
-			params: { path: cartId },
-			body: addressData
-		}));
-	}
-	/**
-	* Apply a coupon to the cart
-	*
-	* @param cartId - The ID of the cart
-	* @param couponCode - The coupon code
-	* @returns Promise with updated cart
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.applyCoupon(
-	*   { id: "01H9CART12345ABCDE" },
-	*   { coupon_code: "FLAT100OFF" }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to apply coupon:", error.message);
-	* } else {
-	*   console.log("Coupon applied, new total:", data.cart.total_amount);
-	*   console.log("Discount amount:", data.cart.coupon_discount_amount);
-	* }
-	* ```
-	*/
-	async applyCoupon(cartId, couponCode) {
-		return this.executeRequest(() => this.client.POST("/carts/{id}/coupon", {
-			params: { path: cartId },
-			body: couponCode
-		}));
-	}
-	/**
-	* Remove a coupon from the cart
-	*
-	* @param cartId - The ID of the cart
-	* @returns Promise with updated cart
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.removeCoupon({
-	*   id: "01H9CART12345ABCDE"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to remove coupon:", error.message);
-	* } else {
-	*   console.log("Coupon removed, new total:", data.cart.total_amount);
-	* }
-	* ```
-	*/
-	async removeCoupon(cartId) {
-		return this.executeRequest(() => this.client.DELETE("/carts/{id}/coupon", {
-			params: { path: cartId },
-			body: void 0
-		}));
-	}
-	/**
-	* Redeem loyalty points
-	*
-	* @param cartId - The ID of the cart
-	* @param points - The number of points to redeem
-	* @returns Promise with updated cart
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.redeemLoyaltyPoints(
-	*   { id: "01H9CART12345ABCDE" },
-	*   { points: 500 }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to redeem loyalty points:", error.message);
-	* } else {
-	*   console.log("Points redeemed, new total:", data.cart.total_amount);
-	*   console.log("Points discount:", data.cart.loyalty_points_discount_amount);
-	* }
-	* ```
-	*/
-	async redeemLoyaltyPoints(cartId, points) {
-		return this.executeRequest(() => this.client.POST("/carts/{id}/loyalty-points", {
-			params: { path: cartId },
-			body: points
-		}));
-	}
-	/**
-	* Remove loyalty points
-	*
-	* @param cartId - The ID of the cart
-	* @returns Promise with updated cart
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.removeLoyaltyPoints({
-	*   id: "01H9CART12345ABCDE"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to remove loyalty points:", error.message);
-	* } else {
-	*   console.log("Loyalty points removed, new total:", data.cart.total_amount);
-	* }
-	* ```
-	*/
-	async removeLoyaltyPoints(cartId) {
-		return this.executeRequest(() => this.client.DELETE("/carts/{id}/loyalty-points", {
-			params: { path: cartId },
-			body: void 0
-		}));
-	}
-	/**
-	* Update shipping method
-	*
-	* @param cartId - The ID of the cart
-	* @param body - The body of the request
-	* @returns Promise with updated cart
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.updateShippingMethod(
-	*   { id: "01H9CART12345ABCDE" },
-	*   {
-	*     shipping_method_id: "01H9SHIP12345FAST",
-	*     estimated_delivery_date: "2024-01-15"
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to update shipping method:", error.message);
-	* } else {
-	*   console.log("Shipping method updated:", data.cart.shipping_method?.name);
-	*   console.log("Shipping cost:", data.cart.shipping_cost);
-	* }
-	* ```
-	*/
-	async updateShippingMethod(cartId, body) {
-		return this.executeRequest(() => this.client.POST("/carts/{id}/shipping-method", {
-			params: { path: cartId },
-			body
-		}));
-	}
-	/**
-	* Use credit balance
-	*
-	* @param cartId - The ID of the cart
-	* @param body - The body of the request
-	* @returns Promise with updated cart
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.redeemCreditBalance(
-	*   { id: "01H9CART12345ABCDE" },
-	*   { amount: 250.00 }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to redeem credit balance:", error.message);
-	* } else {
-	*   console.log("Credit applied, new total:", data.cart.total_amount);
-	*   console.log("Credit discount:", data.cart.credit_balance_discount_amount);
-	* }
-	* ```
-	*/
-	async redeemCreditBalance(cartId, body) {
-		return this.executeRequest(() => this.client.POST("/carts/{id}/credit-balance", {
-			params: { path: cartId },
-			body
-		}));
-	}
-	/**
-	* Remove credit balance
-	*
-	* @param cartId - The ID of the cart
-	* @returns Promise with updated cart
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.removeCreditBalance({
-	*   id: "01H9CART12345ABCDE"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to remove credit balance:", error.message);
-	* } else {
-	*   console.log("Credit balance removed, new total:", data.cart.total_amount);
-	* }
-	* ```
-	*/
-	async removeCreditBalance(cartId) {
-		return this.executeRequest(() => this.client.DELETE("/carts/{id}/credit-balance", {
-			params: { path: cartId },
-			body: void 0
-		}));
-	}
-	/**
-	* Redeem gift card
-	*
-	* @param cartId - The ID of the cart
-	* @param body - The body of the request
-	* @returns Promise with updated cart
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.redeemGiftCard(
-	*   { id: "01H9CART12345ABCDE" },
-	*   {
-	*     gift_card_code: "GIFT2024-ABCD-1234",
-	*     amount: 100.00
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to redeem gift card:", error.message);
-	* } else {
-	*   console.log("Gift card applied, new total:", data.cart.total_amount);
-	*   console.log("Gift card discount:", data.cart.gift_card_discount_amount);
-	* }
-	* ```
-	*/
-	async redeemGiftCard(cartId, body) {
-		return this.executeRequest(() => this.client.POST("/carts/{id}/gift-card", {
-			params: { path: cartId },
-			body
-		}));
-	}
-	/**
-	* Remove gift card
-	*
-	* @param cartId - The ID of the cart
-	* @returns Promise with updated cart
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.removeGiftCard({
-	*   id: "01H9CART12345ABCDE"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to remove gift card:", error.message);
-	* } else {
-	*   console.log("Gift card removed, new total:", data.cart.total_amount);
-	* }
-	* ```
-	*/
-	async removeGiftCard(cartId) {
-		return this.executeRequest(() => this.client.DELETE("/carts/{id}/gift-card", {
-			params: { path: cartId },
-			body: void 0
-		}));
-	}
-	/**
-	* Get wishlist items
-	*
-	* @param userId - The ID of the user
-	* @returns Promise with wishlist items
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.getWishlist({
-	*   user_id: "01H9USER12345ABCDE"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get wishlist:", error.message);
-	* } else {
-	*   const products = data.products;
-	*   console.log("Wishlist items:", products.length);
-	*   products.forEach(product => {
-	*     console.log("Product:", product.name, "Price:", product.price);
-	*   });
-	* }
-	* ```
-	*/
-	async getWishlist(userId) {
-		return this.executeRequest(() => this.client.GET("/wishlist/{user_id}", { params: { path: userId } }));
-	}
-	/**
-	* Add item to wishlist
-	*
-	* @param userId - The ID of the user
-	* @param itemId - The ID of the item
-	* @returns Promise with updated wishlist
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.addToWishlist(
-	*   { user_id: "01H9USER12345ABCDE" },
-	*   {
-	*     product_id: "01F3Z7KG06J4ACWH1C4926KJEC",
-	*     variant_id: null
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to add to wishlist:", error.message);
-	* } else {
-	*   const products = data.products;
-	*   console.log("Item added to wishlist, total items:", products.length);
-	* }
-	* ```
-	*/
-	async addToWishlist(userId, itemId) {
-		return this.executeRequest(() => this.client.POST("/wishlist/{user_id}", {
-			params: { path: userId },
-			body: itemId
-		}));
-	}
-	/**
-	* Remove item from wishlist
-	*
-	* @param userId - The ID of the user
-	* @param body - The body containing product details to remove
-	* @returns Promise with updated wishlist
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.removeFromWishlist(
-	*   { user_id: "01H9USER12345ABCDE" },
-	*   {
-	*     product_id: "01F3Z7KG06J4ACWH1C4926KJEC",
-	*     variant_id: null
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to remove from wishlist:", error.message);
-	* } else {
-	*   const products = data.products;
-	*   console.log("Item removed from wishlist, remaining items:", products.length);
-	* }
-	* ```
-	*/
-	async removeFromWishlist(userId, body) {
-		return this.executeRequest(() => this.client.DELETE("/wishlist/{user_id}", {
-			params: { path: userId },
-			body
-		}));
-	}
-	/**
-	* Get all available coupons
-	*
-	* @param headers - Optional header parameters (customer_group_id, etc.)
-	* @returns Promise with all available coupons
-	* @example
-	* ```typescript
-	* // Get all available coupons
-	* const { data, error } = await sdk.cart.getAvailableCoupons();
-	*
-	* if (error) {
-	*   console.error("Failed to get available coupons:", error.message);
-	* } else {
-	*   const coupons = data.coupons || [];
-	*   console.log("Available coupons:", coupons.length);
-	*   coupons.forEach(coupon => {
-	*     console.log("Coupon:", coupon.code, "Discount:", coupon.discount_amount);
-	*   });
-	* }
-	*
-	* // Override customer group ID for this specific request
-	* const { data: overrideData, error: overrideError } = await sdk.cart.getAvailableCoupons({
-	*   "x-customer-group-id": "01H9GROUP12345ABC" // Override default SDK config
-	* });
-	* ```
-	*/
-	async getAvailableCoupons(headers) {
-		const mergedHeaders = this.mergeHeaders(headers);
-		return this.executeRequest(() => this.client.GET("/carts/available-coupons", { params: { header: mergedHeaders } }));
-	}
-	/**
-	* Get all available promotions
-	*
-	* @param headers - Optional header parameters (customer_group_id, etc.)
-	* @returns Promise with all available promotions
-	* @example
-	* ```typescript
-	* // Get all available promotions
-	* const { data, error } = await sdk.cart.getAvailablePromotions();
-	*
-	* if (error) {
-	*   console.error("Failed to get available promotions:", error.message);
-	* } else {
-	*   const promotions = data.promotions || [];
-	*   console.log("Available promotions:", promotions.length);
-	*   promotions.forEach(promotion => {
-	*     console.log("Promotion:", promotion.name, "Type:", promotion.promotion_type);
-	*   });
-	* }
-	*
-	* // Override customer group ID for this specific request
-	* const { data: overrideData, error: overrideError } = await sdk.cart.getAvailablePromotions({
-	*   "x-customer-group-id": "01H9GROUP12345ABC" // Override default SDK config
-	* });
-	* ```
-	*/
-	async getAvailablePromotions(headers) {
-		const mergedHeaders = this.mergeHeaders(headers);
-		return this.executeRequest(() => this.client.GET("/carts/available-promotions", { params: { header: mergedHeaders } }));
-	}
-	/**
-	* Evaluate promotions
-	*
-	* @param cartId - The ID of the cart
-	* @returns Promise with evaluated promotions
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.evaluatePromotions({
-	*   id: "01H9CART12345ABCDE"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to evaluate promotions:", error.message);
-	* } else {
-	*   const applicable = data.applicable_promotions || [];
-	*   const inapplicable = data.inapplicable_promotions || [];
-	*
-	*   console.log("Applicable promotions:", applicable.length);
-	*   applicable.forEach(promo => {
-	*     console.log(`- ${promo.name}: ${promo.savings_message}`);
-	*   });
-	*
-	*   console.log("Inapplicable promotions:", inapplicable.length);
-	*   inapplicable.forEach(promo => {
-	*     console.log(`- ${promo.name}: ${promo.reason}`);
-	*   });
-	* }
-	* ```
-	*/
-	async evaluatePromotions(cartId) {
-		return this.executeRequest(() => this.client.GET("/carts/{id}/evaluate-promotions", { params: { path: cartId } }));
-	}
-	/**
-	* Evaluate coupons
-	*
-	* @param cartId - The ID of the cart
-	* @returns Promise with evaluated coupons
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.cart.evaluateCoupons({
-	*   id: "01H9CART12345ABCDE"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to evaluate coupons:", error.message);
-	* } else {
-	*   const applicable = data.applicable_coupons || [];
-	*   const inapplicable = data.inapplicable_coupons || [];
-	*
-	*   console.log("Applicable coupons:", applicable.length);
-	*   applicable.forEach(coupon => {
-	*     console.log(`- ${coupon.code}: Save $${coupon.estimated_discount}`);
-	*   });
-	*
-	*   console.log("Inapplicable coupons:", inapplicable.length);
-	*   inapplicable.forEach(coupon => {
-	*     console.log(`- ${coupon.code}: ${coupon.reason}`);
-	*   });
-	* }
-	* ```
-	*/
-	async evaluateCoupons(cartId) {
-		return this.executeRequest(() => this.client.GET("/carts/{id}/evaluate-coupons", { params: { path: cartId } }));
-	}
-};
-
-//#endregion
-//#region src/lib/auth.ts
-/**
-* Client for interacting with authentication endpoints
-*/
-var AuthClient = class extends StorefrontAPIClient {
-	/**
-	* Get anonymous token for guest users
-	*
-	* @example
-	* ```typescript
-	* // Get token for guest browsing
-	* const { data, error } = await sdk.auth.getAnonymousToken();
-	*
-	* if (error) {
-	*   console.error("Failed to get anonymous token:", error.message);
-	* } else {
-	*   console.log("Anonymous token:", data.access_token);
-	*   // Store token or proceed with guest operations
-	* }
-	* ```
-	*/
-	async getAnonymousToken() {
-		return this.executeRequest(() => this.client.POST("/auth/anonymous"));
-	}
-	/**
-	* Login with phone number
-	*
-	* @param body - Login request body containing phone number and options
-	* @returns Promise with OTP token and action
-	* @example
-	* ```typescript
-	* // Login with phone number
-	* const { data, error } = await sdk.auth.loginWithPhone({
-	*   phoneNumber: "9876543210",
-	*   countryCode: "+91",
-	*   registerIfNotExists: true
-	* });
-	*
-	* if (error) {
-	*   console.error("Login failed:", error.message);
-	* } else {
-	*   console.log("OTP sent. Token:", data.otpToken);
-	*   console.log("Action:", data.action); // "login" or "register"
-	*   // Redirect user to OTP verification screen
-	* }
-	* ```
-	*/
-	async loginWithPhone(body) {
-		return this.executeRequest(() => this.client.POST("/auth/login/phone", { body }));
-	}
-	/**
-	* Login with WhatsApp
-	*
-	* @param body - Login request body containing phone number and options
-	* @returns Promise with OTP token and action
-	* @example
-	* ```typescript
-	* // Login with WhatsApp number
-	* const { data, error } = await sdk.auth.loginWithWhatsApp({
-	*   phone: "9876543210",
-	*   country_code: "+91",
-	*   register_if_not_exists: true
-	* });
-	*
-	* if (error) {
-	*   console.error("WhatsApp login failed:", error.message);
-	* } else {
-	*   console.log("OTP sent to WhatsApp. Token:", data.otp_token);
-	*   console.log("Action:", data.otp_action); // "login" or "register"
-	* }
-	* ```
-	*/
-	async loginWithWhatsApp(body) {
-		return this.executeRequest(() => this.client.POST("/auth/login/whatsapp", { body }));
-	}
-	/**
-	* Login with email
-	*
-	* @param body - Login request body containing email and options
-	* @returns Promise with OTP token and action
-	* @example
-	* ```typescript
-	* // Login with email address
-	* const { data, error } = await sdk.auth.loginWithEmail({
-	*   email: "customer@example.com",
-	*   registerIfNotExists: true
-	* });
-	*
-	* if (error) {
-	*   console.error("Email login failed:", error.message);
-	* } else {
-	*   console.log("OTP sent to email. Token:", data.otpToken);
-	*   console.log("Action:", data.action); // "login" or "register"
-	*   // Show OTP input form
-	* }
-	* ```
-	*/
-	async loginWithEmail(body) {
-		return this.executeRequest(() => this.client.POST("/auth/login/email", { body }));
-	}
-	/**
-	* Login with password
-	*
-	* @param body - Login credentials containing email/phone and password
-	* @returns Promise with user info and tokens
-	* @example
-	* ```typescript
-	* // Login with email and password
-	* const { data, error } = await sdk.auth.loginWithPassword({
-	*   email: "customer@example.com",
-	*   password: "securePassword123"
-	* });
-	*
-	* if (error) {
-	*   console.error("Password login failed:", error.message);
-	* } else {
-	*   console.log("Login successful:", data.user.email);
-	*   console.log("Access token:", data.access_token);
-	* }
-	* ```
-	*/
-	async loginWithPassword(body) {
-		return this.executeRequest(() => this.client.POST("/auth/login/password", { body }));
-	}
-	/**
-	* Forgot password
-	*
-	* @param body - Request body containing email address
-	* @returns Promise with password reset information
-	* @example
-	* ```typescript
-	* // Send password reset email
-	* const { data, error } = await sdk.auth.forgotPassword({
-	*   email: "customer@example.com"
-	* });
-	*
-	* if (error) {
-	*   console.error("Password reset failed:", error.message);
-	* } else {
-	*   console.log("Reset email sent successfully");
-	*   // Show confirmation message to user
-	* }
-	* ```
-	*/
-	async forgotPassword(body) {
-		return this.executeRequest(() => this.client.POST("/auth/forgot-password", { body }));
-	}
-	/**
-	* Reset password
-	*
-	* @param body - Reset password request body containing new password and OTP token
-	* @returns Promise with new access and refresh tokens
-	* @example
-	* ```typescript
-	* // Reset password with OTP token from forgot password flow
-	* const { data, error } = await sdk.auth.resetPassword({
-	*   new_password: "newSecurePassword123",
-	*   confirm_password: "newSecurePassword123",
-	*   otp_token: "abc123otptoken"
-	* });
-	*
-	* if (error) {
-	*   console.error("Password reset failed:", error.message);
-	* } else {
-	*   console.log("Password reset successful");
-	*   console.log("New access token:", data.access_token);
-	* }
-	* ```
-	*/
-	async resetPassword(body) {
-		return this.executeRequest(() => this.client.POST("/auth/reset-password", { body }));
-	}
-	/**
-	* Change password
-	*
-	* @param body - Change password request body containing old and new passwords
-	* @returns Promise with new access and refresh tokens
-	* @example
-	* ```typescript
-	* // Change user's password
-	* const { data, error } = await sdk.auth.changePassword({
-	*   old_password: "currentPassword123",
-	*   new_password: "newSecurePassword456",
-	*   confirm_password: "newSecurePassword456"
-	* });
-	*
-	* if (error) {
-	*   console.error("Password change failed:", error.message);
-	* } else {
-	*   console.log("Password changed successfully");
-	*   console.log("New access token:", data.access_token);
-	* }
-	* ```
-	*/
-	async changePassword(body) {
-		return this.executeRequest(() => this.client.POST("/auth/change-password", { body }));
-	}
-	/**
-	* Verify OTP
-	*
-	* @param body - OTP verification data including code and tokens
-	* @returns Promise with user info and tokens
-	* @example
-	* ```typescript
-	* // Verify OTP after login attempt
-	* const { data, error } = await sdk.auth.verifyOtp({
-	*   otp: "1234",
-	*   otpToken: "56895455",
-	*   otpAction: "login" // or "register"
-	* });
-	*
-	* if (error) {
-	*   console.error("OTP verification failed:", error.message);
-	*   // Show error message, allow retry
-	* } else {
-	*   console.log("Login successful:", data.user.email);
-	*   console.log("User ID:", data.user.id);
-	* }
-	* ```
-	*/
-	async verifyOtp(body) {
-		return this.executeRequest(() => this.client.POST("/auth/verify-otp", { body }));
-	}
-	/**
-	* Register with phone
-	*
-	* @param body - Registration details including phone number and user information
-	* @returns Promise with user info and tokens
-	* @example
-	* ```typescript
-	* // Register a new user with phone number
-	* const { data, error } = await sdk.auth.registerWithPhone({
-	*   phone: "9876543210",
-	*   country_code: "+91",
-	*   first_name: "John",
-	*   last_name: "Doe",
-	*   email: "john.doe@example.com"
-	* });
-	*
-	* if (error) {
-	*   console.error("Phone registration failed:", error.message);
-	* } else {
-	*   console.log("Registration successful:", data.user.first_name);
-	*   console.log("User ID:", data.user.id);
-	*   console.log("Access token:", data.access_token);
-	* }
-	* ```
-	*/
-	async registerWithPhone(body) {
-		return this.executeRequest(() => this.client.POST("/auth/register/phone", { body }));
-	}
-	/**
-	* Register with email
-	*
-	* @param body - Registration details including email and user information
-	* @returns Promise with user info and tokens
-	* @example
-	* ```typescript
-	* // Register a new user with email address
-	* const { data, error } = await sdk.auth.registerWithEmail({
-	*   email: "jane.smith@example.com",
-	*   first_name: "Jane",
-	*   last_name: "Smith",
-	*   phone: "9876543210"
-	* });
-	*
-	* if (error) {
-	*   console.error("Email registration failed:", error.message);
-	* } else {
-	*   console.log("Registration successful:", data.user.email);
-	*   console.log("User ID:", data.user.id);
-	*   console.log("Access token:", data.access_token);
-	* }
-	* ```
-	*/
-	async registerWithEmail(body) {
-		return this.executeRequest(() => this.client.POST("/auth/register/email", { body }));
-	}
-	/**
-	* Refresh the access token using a refresh token
-	* @param body - Request body containing the refresh token
-	* @returns Promise with the new access token and refresh token
-	* @example
-	* ```typescript
-	* // Refresh access token when it expires
-	* const { data, error } = await sdk.auth.refreshToken({
-	*   refresh_token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
-	* });
-	*
-	* if (error) {
-	*   console.error("Token refresh failed:", error.message);
-	*   // Redirect to login
-	* } else {
-	*   console.log("Token refreshed successfully");
-	*   console.log("New access token:", data.access_token);
-	*   console.log("New refresh token:", data.refresh_token);
-	* }
-	* ```
-	*/
-	async refreshToken(body) {
-		return this.executeRequest(() => this.client.POST("/auth/refresh-token", { body }));
-	}
-	/**
-	* Logout
-	*
-	* @returns Promise that resolves when logout is complete
-	* @example
-	* ```typescript
-	* // Logout current user
-	* const { data, error } = await sdk.auth.logout();
-	*
-	* if (error) {
-	*   console.error("Logout failed:", error.message);
-	* } else {
-	*   console.log("Logout successful");
-	*   console.log("Session ended for user:", data.user.email);
-	* }
-	* ```
-	*/
-	async logout() {
-		return this.executeRequest(() => this.client.POST("/auth/logout"));
-	}
-	/**
-	* Get user details
-	*
-	* @param pathParams - Path parameters containing user ID
-	* @returns Promise with user details
-	* @example
-	* ```typescript
-	* // Get details for a specific user
-	* const { data, error } = await sdk.auth.getUserDetails({
-	*   id: "01H9XYZ12345USERID"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get user details:", error.message);
-	* } else {
-	*   console.log("User details:", data.user);
-	*   console.log("Email:", data.user.email);
-	*   console.log("Phone:", data.user.phoneNumber);
-	*   console.log("Created:", data.user.createdAt);
-	* }
-	* ```
-	*/
-	async getUserDetails(pathParams) {
-		return this.executeRequest(() => this.client.GET("/auth/user/{id}", { params: { path: pathParams } }));
-	}
-	/**
-	* Update user details
-	*
-	* @param pathParams - Path parameters containing user ID
-	* @param body - Updated user information
-	* @returns Promise with updated user details
-	* @example
-	* ```typescript
-	* // Update user profile information
-	* const { data, error } = await sdk.auth.updateUserDetails(
-	*   { id: "01H9XYZ12345USERID" },
-	*   {
-	*     first_name: "John",
-	*     last_name: "Doe",
-	*     email: "john.doe@example.com",
-	*     phone: "9876543210",
-	*     country_code: "+91"
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to update user:", error.message);
-	* } else {
-	*   console.log("User updated successfully:", data.user.first_name);
-	* }
-	* ```
-	*/
-	async updateUserDetails(pathParams, body) {
-		return this.executeRequest(() => this.client.PUT("/auth/user/{id}", {
-			params: { path: pathParams },
-			body
-		}));
-	}
-	/**
-	* Add profile image
-	*
-	* @param pathParams - Path parameters containing user ID
-	* @param formData - Form data containing the image file
-	* @returns Promise with profile image URL
-	* @example
-	* ```typescript
-	* // Add profile image for a user
-	* const imageFile = document.getElementById('file-input').files[0];
-	* const { data, error } = await sdk.auth.addProfileImage(
-	*   { id: "01H9XYZ12345USERID" },
-	*   { image: imageFile }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to add profile image:", error.message);
-	* } else {
-	*   console.log("Profile image added successfully");
-	*   console.log("Image URL:", data.profile_image_url);
-	* }
-	* ```
-	*/
-	async addProfileImage(pathParams, formData) {
-		return this.executeRequest(() => this.client.POST("/auth/user/{id}/profile-image", {
-			params: { path: pathParams },
-			body: formData,
-			bodySerializer: (body) => {
-				const fd = new FormData();
-				for (const [key, value] of Object.entries(body)) if (value !== void 0 && value !== null) fd.append(key, value);
-				return fd;
-			}
-		}));
-	}
-	/**
-	* Update profile image
-	*
-	* @param pathParams - Path parameters containing user ID
-	* @param formData - Form data containing the new image file
-	* @returns Promise with updated profile image URL
-	* @example
-	* ```typescript
-	* // Update existing profile image
-	* const newImageFile = document.getElementById('file-input').files[0];
-	* const { data, error } = await sdk.auth.updateProfileImage(
-	*   { id: "01H9XYZ12345USERID" },
-	*   { image: newImageFile }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to update profile image:", error.message);
-	* } else {
-	*   console.log("Profile image updated successfully");
-	*   console.log("New image URL:", data.profile_image_url);
-	* }
-	* ```
-	*/
-	async updateProfileImage(pathParams, formData) {
-		return this.executeRequest(() => this.client.PUT("/auth/user/{id}/profile-image", {
-			params: { path: pathParams },
-			body: formData,
-			bodySerializer: (body) => {
-				const fd = new FormData();
-				for (const [key, value] of Object.entries(body)) if (value !== void 0 && value !== null) fd.append(key, value);
-				return fd;
-			}
-		}));
-	}
-	/**
-	* Delete profile image
-	*
-	* @param pathParams - Path parameters containing user ID
-	* @returns Promise with deletion confirmation
-	* @example
-	* ```typescript
-	* // Delete user's profile image
-	* const { data, error } = await sdk.auth.deleteProfileImage({
-	*   id: "01H9XYZ12345USERID"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to delete profile image:", error.message);
-	* } else {
-	*   console.log("Profile image deleted successfully");
-	*   console.log("Success:", data.success);
-	* }
-	* ```
-	*/
-	async deleteProfileImage(pathParams) {
-		return this.executeRequest(() => this.client.DELETE("/auth/user/{id}/profile-image", { params: { path: pathParams } }));
-	}
-	/**
-	* Get profile image
-	*
-	* @param pathParams - Path parameters containing user ID
-	* @returns Promise with profile image URL
-	* @example
-	* ```typescript
-	* // Get user's profile image URL
-	* const { data, error } = await sdk.auth.getProfileImage({
-	*   id: "01H9XYZ12345USERID"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get profile image:", error.message);
-	* } else {
-	*   console.log("Profile image URL:", data.profile_image_url);
-	* }
-	* ```
-	*/
-	async getProfileImage(pathParams) {
-		return this.executeRequest(() => this.client.GET("/auth/user/{id}/profile-image", { params: { path: pathParams } }));
-	}
-	/**
-	* Deactivate user account
-	*
-	* @param pathParams - Path parameters containing user ID
-	* @returns Promise with deactivation confirmation
-	* @example
-	* ```typescript
-	* // Deactivate a user account
-	* const { data, error } = await sdk.auth.deactivateUserAccount({
-	*   id: "01H9XYZ12345USERID"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to deactivate account:", error.message);
-	* } else {
-	*   console.log("Account deactivated successfully");
-	*   console.log("Success:", data.success);
-	* }
-	* ```
-	*/
-	async deactivateUserAccount(pathParams) {
-		return this.executeRequest(() => this.client.PUT("/auth/user/{id}/deactivate", { params: { path: pathParams } }));
-	}
-	/**
-	* Get user notification preferences
-	*
-	* @param pathParams - Path parameters containing user ID
-	* @returns Promise with user's notification preferences
-	* @example
-	* ```typescript
-	* // Get user's notification preferences
-	* const { data, error } = await sdk.auth.getUserNotificationPreferences({
-	*   id: "01H9XYZ12345USERID"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get preferences:", error.message);
-	* } else {
-	*   console.log("Notification preferences:", data.notification_preferences);
-	* }
-	* ```
-	*/
-	async getUserNotificationPreferences(pathParams) {
-		return this.executeRequest(() => this.client.GET("/auth/user/{id}/notification-preferences", { params: { path: pathParams } }));
-	}
-	/**
-	* Update user notification preferences
-	*
-	* @param pathParams - Path parameters containing user ID
-	* @param body - Updated notification preferences
-	* @returns Promise with updated notification preferences
-	* @example
-	* ```typescript
-	* // Update user's notification preferences
-	* const { data, error } = await sdk.auth.updateUserNotificationPreferences(
-	*   { id: "01H9XYZ12345USERID" },
-	*   {
-	*     email_notifications: true,
-	*     sms_notifications: false,
-	*     push_notifications: true
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to update preferences:", error.message);
-	* } else {
-	*   console.log("Preferences updated successfully");
-	* }
-	* ```
-	*/
-	async updateUserNotificationPreferences(pathParams, body) {
-		return this.executeRequest(() => this.client.PUT("/auth/user/{id}/notification-preferences", {
-			params: { path: pathParams },
-			body
-		}));
-	}
-	/**
-	* Create user notification preference
-	*
-	* @param pathParams - Path parameters containing user ID
-	* @param body - Notification preferences to create
-	* @returns Promise with created notification preferences
-	* @example
-	* ```typescript
-	* // Create notification preferences for a user
-	* const { data, error } = await sdk.auth.createUserNotificationPreference(
-	*   { id: "01H9XYZ12345USERID" },
-	*   {
-	*     email_notifications: true,
-	*     sms_notifications: true,
-	*     push_notifications: false
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to create preferences:", error.message);
-	* } else {
-	*   console.log("Preferences created successfully");
-	* }
-	* ```
-	*/
-	async createUserNotificationPreference(pathParams, body) {
-		return this.executeRequest(() => this.client.POST("/auth/user/{id}/notification-preferences", {
-			params: { path: pathParams },
-			body
-		}));
-	}
-	/**
-	* Generate OTP
-	*
-	* @param body - OTP generation body (phone or email)
-	* @returns Promise with OTP token and action
-	* @example
-	* ```typescript
-	* // Generate OTP for phone number
-	* const { data, error } = await sdk.auth.generateOtp({
-	*   phone: "9876543210",
-	*   country_code: "+91"
-	* });
-	*
-	* if (error) {
-	*   console.error("OTP generation failed:", error.message);
-	* } else {
-	*   console.log("OTP sent successfully");
-	*   console.log("OTP token:", data.otp_token);
-	*   console.log("Action:", data.otp_action);
-	* }
-	* ```
-	*/
-	async generateOtp(body) {
-		return this.executeRequest(() => this.client.POST("/auth/generate-otp", { body }));
-	}
-	/**
-	* Check whether email or phone is already verified
-	*
-	* @param body - Request body containing phone numbers or email addresses to verify
-	* @returns Promise with verification status for provided contacts
-	* @example
-	* ```typescript
-	* // Check verification status for multiple contacts
-	* const { data, error } = await sdk.auth.checkEmailOrPhoneIsVerified({
-	*   phone: ["9876543210", "9123456789"],
-	*   email: ["user1@example.com", "user2@example.com"]
-	* });
-	*
-	* if (error) {
-	*   console.error("Verification check failed:", error.message);
-	* } else {
-	*   console.log("Verified phones:", data.verified_phone);
-	*   console.log("Verified emails:", data.verified_email);
-	* }
-	* ```
-	*/
-	async checkEmailOrPhoneIsVerified(body) {
-		return this.executeRequest(() => this.client.POST("/auth/verified-email-phone", { body }));
-	}
-};
-
-//#endregion
-//#region src/lib/order.ts
-/**
-* Client for interacting with order endpoints
-*/
-var OrderClient = class extends StorefrontAPIClient {
-	/**
-	* Get order details
-	*
-	* @param orderNumber - Order number
-	* @returns Promise with order details
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.order.getOrderDetails({
-	*   order_number: "ORD-2024-001"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get order details:", error.message);
-	* } else {
-	*   console.log("Order details:", data.content.order);
-	*   console.log("Order status:", data.content.order.status);
-	*   console.log("Total amount:", data.content.order.total_amount);
-	* }
-	* ```
-	*/
-	async getOrderDetails(pathParams) {
-		return this.executeRequest(() => this.client.GET("/orders/{order_number}", { params: { path: pathParams } }));
-	}
-	/**
-	* Create order
-	*
-	* @param body - Order creation request body
-	* @returns Promise with order details
-	* @example
-	* ```typescript
-	* // Example with PayU payment gateway
-	* const { data, error } = await sdk.order.createOrder({
-	*   cart_id: "cart_01H9XYZ12345ABCDE",
-	*   payment_gateway: "PAYU",
-	*   payment_gateway_params: {
-	*     payment_gateway: "PAYU",
-	*     furl: "https://yourapp.com/payment/failure",
-	*     surl: "https://yourapp.com/payment/success"
-	*   }
-	* });
-	*
-	* // Example with Juspay payment gateway
-	* const { data, error } = await sdk.order.createOrder({
-	*   cart_id: "cart_01H9XYZ12345ABCDE",
-	*   payment_gateway: "JUSPAY",
-	*   payment_gateway_params: {
-	*     payment_gateway: "JUSPAY",
-	*     action: "paymentPage",
-	*     integration_type: "hyper-checkout",
-	*     return_url: "https://yourapp.com/payment/return",
-	*     gateway_reference_id: "juspay_gateway_ref_123"
-	*   }
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to create order:", error.message);
-	* } else {
-	*   console.log("Order created:", data.content.order.id);
-	*   console.log("Payment required:", data.content.payment_required);
-	*   console.log("Payment info:", data.content.payment_info);
-	* }
-	* ```
-	*/
-	async createOrder(body) {
-		return this.executeRequest(() => this.client.POST("/orders", { body }));
-	}
-	/**
-	* List all orders
-	*
-	* @param queryParams - Query parameters for filtering and pagination
-	* @returns Promise with order list
-	* @example
-	* ```typescript
-	* // Basic usage - only required parameter
-	* const { data, error } = await sdk.order.listOrders({
-	*   user_id: "user_01H9XYZ12345ABCDE"
-	* });
-	*
-	* // Advanced usage with optional parameters
-	* const { data, error } = await sdk.order.listOrders({
-	*   user_id: "user_01H9XYZ12345ABCDE",
-	*   page: 1,
-	*   limit: 20,
-	*   sort_by: '{"created_at":"desc"}',
-	*   status: ["confirmed", "shipped", "delivered"]
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to list orders:", error.message);
-	* } else {
-	*   console.log("Orders found:", data.content.orders?.length || 0);
-	*   console.log("Pagination:", data.content.pagination);
-	*
-	*   data.content.orders?.forEach(order => {
-	*     console.log(`Order ${order.order_number}: ${order.status}`);
-	*   });
-	* }
-	* ```
-	*/
-	async listOrders(queryParams) {
-		return this.executeRequest(() => this.client.GET("/orders", { params: { query: queryParams } }));
-	}
-	/**
-	* Get payment status for an order
-	*
-	* @param orderNumber - Order number
-	* @returns Promise with payment status
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.order.getPaymentStatus("ORD-2024-001");
-	*
-	* if (error) {
-	*   console.error("Failed to get payment status:", error.message);
-	* } else {
-	*   console.log("Payment status:", data.content.status);
-	*   console.log("Amount paid:", data.content.amount_paid);
-	*   console.log("Amount unpaid:", data.content.amount_unpaid);
-	*   console.log("Retry available:", data.content.is_retry_available);
-	* }
-	* ```
-	*/
-	async getPaymentStatus(orderNumber) {
-		return this.executeRequest(() => this.client.GET("/orders/{order_number}/payment-status", { params: { path: { order_number: orderNumber } } }));
-	}
-	/**
-	* Get all shipments for an order
-	*
-	* @param pathParams - Order number path parameters
-	* @returns Promise with shipments
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.order.listOrderShipments({
-	*   order_number: "ORD-2024-001"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get order shipments:", error.message);
-	* } else {
-	*   console.log("Shipments found:", data.content.shipments?.length || 0);
-	*
-	*   data.content.shipments?.forEach(shipment => {
-	*     console.log(`Shipment ${shipment.id}: ${shipment.status}`);
-	*     console.log("Tracking number:", shipment.tracking_number);
-	*     console.log("Carrier:", shipment.carrier);
-	*   });
-	* }
-	* ```
-	*/
-	async listOrderShipments(pathParams) {
-		return this.executeRequest(() => this.client.GET("/orders/{order_number}/shipments", { params: { path: pathParams } }));
-	}
-	/**
-	* List order payments
-	*
-	* @param pathParams - Order number path parameters
-	* @returns Promise with payments
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.order.listOrderPayments({
-	*   order_number: "ORD-2024-001"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get order payments:", error.message);
-	* } else {
-	*   console.log("Payments found:", data.content.payments?.length || 0);
-	*
-	*   data.content.payments?.forEach(payment => {
-	*     console.log(`Payment ${payment.id}: ${payment.status}`);
-	*     console.log("Amount:", payment.amount);
-	*     console.log("Gateway:", payment.payment_gateway);
-	*     console.log("Transaction ID:", payment.transaction_id);
-	*   });
-	* }
-	* ```
-	*/
-	async listOrderPayments(pathParams) {
-		return this.executeRequest(() => this.client.GET("/orders/{order_number}/payments", { params: { path: pathParams } }));
-	}
-	/**
-	* List order refunds
-	*
-	* @param pathParams - Order number path parameters
-	* @returns Promise with refunds
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.order.listOrderRefunds({
-	*   order_number: "ORD-2024-001"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get order refunds:", error.message);
-	* } else {
-	*   console.log("Refunds found:", data.content.refunds?.length || 0);
-	*
-	*   data.content.refunds?.forEach(refund => {
-	*     console.log(`Refund ${refund.id}: ${refund.status}`);
-	*     console.log("Amount:", refund.amount);
-	*     console.log("Reason:", refund.reason);
-	*     console.log("Processed at:", refund.processed_at);
-	*   });
-	* }
-	* ```
-	*/
-	async listOrderRefunds(pathParams) {
-		return this.executeRequest(() => this.client.GET("/orders/{order_number}/refunds", { params: { path: pathParams } }));
-	}
-	/**
-	* Cancel an order
-	*
-	* @param pathParams - Order number path parameters
-	* @param body - Cancellation request body
-	* @returns Promise with order details
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.order.cancelOrder(
-	*   { order_number: "ORD-2024-001" },
-	*   {
-	*     cancellation_reason: "Customer requested cancellation",
-	*     refund_mode: "original_payment_mode",
-	*     feedback: "Customer changed their mind about the purchase"
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to cancel order:", error.message);
-	* } else {
-	*   console.log("Order cancelled successfully");
-	*   console.log("Updated order status:", data.content.order?.status);
-	*   console.log("Cancellation reason:", data.content.order?.cancellation_reason);
-	* }
-	* ```
-	*/
-	async cancelOrder(pathParams, body) {
-		return this.executeRequest(() => this.client.POST("/orders/{order_number}/cancel", {
-			params: { path: pathParams },
-			body
-		}));
-	}
-	/**
-	* Retry payment for an order
-	*
-	* @param pathParams - Order number path parameters
-	* @param body - Payment retry request body
-	* @returns Promise with payment information
-	* @example
-	* ```typescript
-	* // Example with PayU payment gateway
-	* const { data, error } = await sdk.order.retryOrderPayment(
-	*   { order_number: "ORD-2024-001" },
-	*   {
-	*     payment_gateway_params: {
-	*       payment_gateway: "PAYU",
-	*       furl: "https://yourapp.com/payment/failure",
-	*       surl: "https://yourapp.com/payment/success"
-	*     }
-	*   }
-	* );
-	*
-	* // Example with Juspay payment gateway
-	* const { data, error } = await sdk.order.retryOrderPayment(
-	*   { order_number: "ORD-2024-001" },
-	*   {
-	*     payment_gateway_params: {
-	*       payment_gateway: "JUSPAY",
-	*       action: "paymentPage",
-	*       integration_type: "hyper-checkout",
-	*       return_url: "https://yourapp.com/payment/return",
-	*       gateway_reference_id: "juspay_gateway_ref_123"
-	*     }
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to retry payment:", error.message);
-	* } else {
-	*   console.log("Payment retry initiated");
-	*   console.log("Payment info:", data.content.payment_info);
-	*   console.log("Transaction ID:", data.content.payment_info.transaction_id);
-	* }
-	* ```
-	*/
-	async retryOrderPayment(pathParams, body) {
-		return this.executeRequest(() => this.client.POST("/orders/{order_number}/retry-payment", {
-			params: { path: pathParams },
-			body
-		}));
-	}
-};
-
-//#endregion
-//#region src/lib/shipping.ts
-/**
-* Client for interacting with shipping endpoints
-*/
-var ShippingClient = class extends StorefrontAPIClient {
-	/**
-	* Get shipping options for an order
-	*
-	* @param body - Shipping methods body
-	* @returns Promise with shipping options
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.shipping.getShippingMethods({
-	*   delivery_pincode: "400001",
-	*   cart_id: "cart_01H9XYZ12345ABCDE"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get shipping methods:", error.message);
-	* } else {
-	*   console.log("Is serviceable:", data.content.is_serviceable);
-	*   console.log("Available shipping methods:", data.content.shipping_methods?.length || 0);
-	*
-	*   data.content.shipping_methods?.forEach(method => {
-	*     console.log(`Method: ${method.name} (${method.shipping_type})`);
-	*     console.log(`Shipping cost: ${method.shipping_amount}`);
-	*     console.log(`Estimated delivery: ${method.estimated_delivery_days} days`);
-	*
-	*     method.courier_companies?.forEach(courier => {
-	*       console.log(`  - ${courier.name}: ${courier.shipping_amount} (${courier.mode})`);
-	*       console.log(`    Rating: ${courier.rating}/5, Recommended: ${courier.is_recommended}`);
-	*     });
-	*   });
-	* }
-	* ```
-	*/
-	async getShippingMethods(body) {
-		return this.executeRequest(() => this.client.POST("/shipping/shipping-methods", { body }));
-	}
-	/**
-	* Check pincode deliverability
-	*
-	* @param pathParams - Path parameters
-	* @returns Promise with pincode deliverability result
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.shipping.checkPincodeDeliverability({
-	*   pincode: "400001"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to check pincode serviceability:", error.message);
-	* } else {
-	*   console.log("Pincode serviceable:", data.content.is_serviceable);
-	*
-	*   if (data.content.is_serviceable) {
-	*     console.log("Delivery is available to this pincode");
-	*   } else {
-	*     console.log("Delivery is not available to this pincode");
-	*   }
-	* }
-	* ```
-	*/
-	async checkPincodeDeliverability(pathParams) {
-		return this.executeRequest(() => this.client.GET("/shipping/serviceability/{pincode}", { params: { path: pathParams } }));
-	}
-};
-
-//#endregion
-//#region src/lib/helper.ts
-/**
-* Client for interacting with helper endpoints
-*/
-var HelpersClient = class extends StorefrontAPIClient {
-	/**
-	* Get a list of countries
-	*
-	* @returns Promise with countries
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.helpers.listCountries();
-	*
-	* if (error) {
-	*   console.error("Failed to get countries:", error);
-	*   return;
-	* }
-	*
-	* console.log("Countries found:", data.countries?.length || 0);
-	*
-	* data.countries?.forEach(country => {
-	*   console.log(`Country: ${country.name} (${country.iso_code})`);
-	*   console.log("Phone code:", country.phone_code);
-	*   console.log("Currency:", country.currency?.code);
-	* });
-	* ```
-	*/
-	async listCountries() {
-		return this.executeRequest(() => this.client.GET("/common/countries", {}));
-	}
-	/**
-	* Get a list of states for a country
-	*
-	* @param pathParams - Path parameters
-	* @returns Promise with states
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.helpers.listCountryStates({
-	*   country_iso_code: "IN"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get states:", error);
-	*   return;
-	* }
-	*
-	* console.log("States found:", data.states?.length || 0);
-	*
-	* data.states?.forEach(state => {
-	*   console.log(`State: ${state.name} (${state.iso_code})`);
-	*   console.log("Type:", state.type);
-	* });
-	*
-	* // Get states for different country
-	* const { data: usStates, error: usError } = await sdk.helpers.listCountryStates({
-	*   country_iso_code: "US"
-	* });
-	*
-	* if (usError) {
-	*   console.error("Failed to get US states:", usError);
-	*   return;
-	* }
-	*
-	* console.log("US States:", usStates.states?.map(s => s.name).join(", "));
-	* ```
-	*/
-	async listCountryStates(pathParams) {
-		return this.executeRequest(() => this.client.GET("/common/countries/{country_iso_code}/states", { params: { path: pathParams } }));
-	}
-	/**
-	* Get pincodes for a country
-	*
-	* @param pathParams - Path parameters
-	* @returns Promise with pincodes
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.helpers.listCountryPincodes({
-	*   country_iso_code: "IN"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get pincodes:", error);
-	*   return;
-	* }
-	*
-	* console.log("Pincodes found:", data.pincodes?.length || 0);
-	*
-	* data.pincodes?.forEach(pincode => {
-	*   console.log(`Pincode: ${pincode.pincode} - ${pincode.city}, ${pincode.state}`);
-	*   console.log("District:", pincode.district);
-	*   console.log("Area:", pincode.area);
-	* });
-	*
-	* // Get pincodes for different country
-	* const { data: usPincodes, error: usError } = await sdk.helpers.listCountryPincodes({
-	*   country_iso_code: "US"
-	* });
-	*
-	* if (usError) {
-	*   console.error("Failed to get US pincodes:", usError);
-	*   return;
-	* }
-	*
-	* console.log("US Pincodes:", usPincodes.pincodes?.map(p => p.pincode).join(", "));
-	* ```
-	*/
-	async listCountryPincodes(pathParams) {
-		return this.executeRequest(() => this.client.GET("/common/countries/{country_iso_code}/pincodes", { params: { path: pathParams } }));
-	}
-};
-
-//#endregion
-//#region src/lib/customer.ts
-/**
-* Client for interacting with customer endpoints
-*/
-var CustomerClient = class extends StorefrontAPIClient {
-	/**
-	* Create a customer
-	*
-	* @param body - Customer creation body
-	* @returns Promise with customer details
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.customer.createCustomer({
-	*   first_name: "John",
-	*   last_name: "Doe",
-	*   email: "john.doe@example.com",
-	*   phone: "+1234567890",
-	*   password: "securePassword123"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to create customer:", error);
-	*   return;
-	* }
-	*
-	* console.log("Customer created:", data.customer_detail);
-	* ```
-	*/
-	async createCustomer(body) {
-		return this.executeRequest(() => this.client.POST("/customers", { body }));
-	}
-	/**
-	* Get customer details
-	*
-	* @param pathParams - Path parameters
-	* @returns Promise with customer details
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.customer.getCustomer({
-	*   id: "customer_123"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get customer:", error);
-	*   return;
-	* }
-	*
-	* console.log("Customer details:", data.customer_detail);
-	* ```
-	*/
-	async getCustomer(pathParams) {
-		return this.executeRequest(() => this.client.GET("/customers/{id}", { params: { path: pathParams } }));
-	}
-	/**
-	* Update a customer
-	*
-	* @param pathParams - Path parameters
-	* @param body - Customer update body
-	* @returns Promise with customer details
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.customer.updateCustomer(
-	*   { id: "customer_123" },
-	*   {
-	*     first_name: "John",
-	*     last_name: "Smith",
-	*     email: "john.smith@example.com"
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to update customer:", error);
-	*   return;
-	* }
-	*
-	* console.log("Customer updated:", data.customer_detail);
-	* ```
-	*/
-	async updateCustomer(pathParams, body) {
-		return this.executeRequest(() => this.client.PUT("/customers/{id}", {
-			params: { path: pathParams },
-			body
-		}));
-	}
-	/**
-	* Get all saved addresses for a customer
-	*
-	* @param pathParams - Path parameters
-	* @returns Promise with addresses
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.customer.listAddresses({
-	*   user_id: "user_456"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to list addresses:", error);
-	*   return;
-	* }
-	*
-	* console.log("Addresses:", data.addresses);
-	* console.log("Pagination:", data.pagination);
-	*
-	* // With pagination
-	* const { data: page2, error: page2Error } = await sdk.customer.listAddresses({
-	*   user_id: "user_456",
-	*   page: 2,
-	*   limit: 10
-	* });
-	* ```
-	*/
-	async listAddresses(pathParams) {
-		return this.executeRequest(() => this.client.GET("/customers/{user_id}/addresses", { params: { path: pathParams } }));
-	}
-	/**
-	* Create a new address for a customer
-	*
-	* @param pathParams - Path parameters
-	* @param body - Address creation body
-	* @returns Promise with address details
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.customer.createAddress(
-	*   { user_id: "user_456" },
-	*   {
-	*     address_line1: "123 Main Street",
-	*     address_line2: "Apt 4B",
-	*     city: "New York",
-	*     state: "NY",
-	*     country: "US",
-	*     pincode: "10001",
-	*     is_default_billing: true,
-	*     is_default_shipping: false
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to create address:", error);
-	*   return;
-	* }
-	*
-	* console.log("Address created:", data.address);
-	* ```
-	*/
-	async createAddress(pathParams, body) {
-		return this.executeRequest(() => this.client.POST("/customers/{user_id}/addresses", {
-			params: { path: pathParams },
-			body
-		}));
-	}
-	/**
-	* Get an address for a customer
-	*
-	* @param pathParams - Path parameters
-	* @returns Promise with address details
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.customer.getAddress({
-	*   user_id: "user_456",
-	*   address_id: "addr_789"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get address:", error);
-	*   return;
-	* }
-	*
-	* console.log("Address details:", data.address);
-	* ```
-	*/
-	async getAddress(pathParams) {
-		return this.executeRequest(() => this.client.GET("/customers/{user_id}/addresses/{address_id}", { params: { path: pathParams } }));
-	}
-	/**
-	* Update an address for a customer
-	*
-	* @param pathParams - Path parameters
-	* @param body - Address update body
-	* @returns Promise with address details
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.customer.updateAddress(
-	*   {
-	*     user_id: "user_456",
-	*     address_id: "addr_789"
-	*   },
-	*   {
-	*     address_line1: "456 Oak Avenue",
-	*     city: "Los Angeles",
-	*     state: "CA",
-	*     pincode: "90210"
-	*   }
-	* );
-	*
-	* if (error) {
-	*   console.error("Failed to update address:", error);
-	*   return;
-	* }
-	*
-	* console.log("Address updated:", data.address);
-	* ```
-	*/
-	async updateAddress(pathParams, body) {
-		return this.executeRequest(() => this.client.PUT("/customers/{user_id}/addresses/{address_id}", {
-			params: { path: pathParams },
-			body
-		}));
-	}
-	/**
-	* Delete an address for a customer
-	*
-	* @param pathParams - Path parameters
-	* @returns Promise with deletion response
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.customer.deleteAddress({
-	*   user_id: "user_456",
-	*   address_id: "addr_789"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to delete address:", error);
-	*   return;
-	* }
-	*
-	* console.log("Address deleted:", data.message);
-	* ```
-	*/
-	async deleteAddress(pathParams) {
-		return this.executeRequest(() => this.client.DELETE("/customers/{user_id}/addresses/{address_id}", { params: { path: pathParams } }));
-	}
-	/**
-	* Get customer loyalty details
-	*
-	* @param pathParams - Path parameters
-	* @returns Promise with loyalty details
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.customer.getLoyaltyDetails({
-	*   user_id: "user_456"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get loyalty details:", error);
-	*   return;
-	* }
-	*
-	* console.log("Loyalty info:", data.loyalty);
-	* console.log("Points balance:", data.loyalty_point_balance);
-	* ```
-	*/
-	async getLoyaltyDetails(pathParams) {
-		return this.executeRequest(() => this.client.GET("/customers/{user_id}/loyalty", { params: { path: pathParams } }));
-	}
-	/**
-	* List all loyalty points activity for a customer
-	*
-	* @param pathParams - Path parameters
-	* @returns Promise with loyalty points activity
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.customer.listLoyaltyPointsActivity({
-	*   user_id: "user_456"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get loyalty activity:", error);
-	*   return;
-	* }
-	*
-	* console.log("Loyalty activity:", data.loyalty_points_activity);
-	*
-	* // With pagination and sorting
-	* const { data: sortedData, error: sortedError } = await sdk.customer.listLoyaltyPointsActivity({
-	*   user_id: "user_456",
-	*   page: 1,
-	*   limit: 20,
-	*   sort_by: JSON.stringify({ "created_at": "desc" })
-	* });
-	* ```
-	*/
-	async listLoyaltyPointsActivity(pathParams) {
-		return this.executeRequest(() => this.client.GET("/customers/{user_id}/loyalty-points-activity", { params: { path: pathParams } }));
-	}
-	/**
-	* List all reviews left by a customer
-	*
-	* @param pathParams - Path parameters
-	* @returns Promise with reviews
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.customer.listCustomerReviews({
-	*   user_id: "user_456"
-	* });
-	*
-	* if (error) {
-	*   console.error("Failed to get customer reviews:", error);
-	*   return;
-	* }
-	*
-	* console.log("Customer reviews:", data.reviews);
-	* console.log("Ready for review:", data.ready_for_review);
-	* ```
-	*/
-	async listCustomerReviews(pathParams) {
-		return this.executeRequest(() => this.client.GET("/customers/{user_id}/reviews", { params: { path: pathParams } }));
-	}
-};
-
-//#endregion
-//#region src/lib/store-config.ts
-/**
-* Client for interacting with store config endpoints
-*/
-var StoreConfigClient = class extends StorefrontAPIClient {
-	/**
-	* Get store config
-	*
-	* @returns Promise with store configuration data
-	*
-	* @example
-	* ```typescript
-	* const { data, error } = await sdk.storeConfig.getStoreConfig();
-	*
-	* if (error) {
-	*   console.error('Failed to get store config:', error.message);
-	*   return;
-	* }
-	*
-	* // Access store configuration data
-	* const storeConfig = data.store_config;
-	* console.log('Store brand:', storeConfig.brand.name);
-	* console.log('Currency:', storeConfig.currency.code);
-	* console.log('KYC enabled:', storeConfig.is_kyc_enabled);
-	* console.log('Customer groups enabled:', storeConfig.is_customer_group_enabled);
-	* ```
-	*/
-	async getStoreConfig() {
-		return this.executeRequest(() => this.client.GET("/store/config"));
-	}
-};
-
-//#endregion
-//#region src/index.ts
-/**
-* Main SDK class for the Storefront API
-*/
-var StorefrontSDK = class {
-	/**
-	* Client for catalog-related endpoints (products, categories, etc.)
-	*/
-	catalog;
-	/**
-	* Client for cart-related endpoints
-	*/
-	cart;
-	/**
-	* Client for authentication-related endpoints
-	*/
-	auth;
-	/**
-	* Client for customer-related endpoints
-	*/
-	customer;
-	/**
-	* Client for helper-related endpoints
-	*/
-	helpers;
-	/**
-	* Client for shipping-related endpoints
-	*/
-	shipping;
-	/**
-	* Client for order-related endpoints
-	*/
-	order;
-	/**
-	* Client for store config-related endpoints
-	*/
-	store;
-	/**
-	* Create a new StorefrontSDK instance
-	*
-	* @param options - Configuration options for the SDK
-	*/
-	constructor(options) {
-		const config = {
-			storeId: options.storeId,
-			environment: options.environment,
-			baseUrl: options.baseUrl,
-			accessToken: options.accessToken,
-			refreshToken: options.refreshToken,
-			apiKey: options.apiKey,
-			timeout: options.timeout,
-			tokenStorage: options.tokenStorage,
-			onTokensUpdated: options.onTokensUpdated,
-			onTokensCleared: options.onTokensCleared,
-			defaultHeaders: options.defaultHeaders,
-			debug: options.debug,
-			logger: options.logger
-		};
-		this.catalog = new CatalogClient(config);
-		this.cart = new CartClient(config);
-		this.auth = new AuthClient(config);
-		this.customer = new CustomerClient(config);
-		this.helpers = new HelpersClient(config);
-		this.shipping = new ShippingClient(config);
-		this.order = new OrderClient(config);
-		this.store = new StoreConfigClient(config);
-	}
-	/**
-	* Set authentication tokens for all clients
-	*
-	* @param accessToken - The access token (required)
-	* @param refreshToken - The refresh token (optional)
-	*
-	* Behavior:
-	* - If tokenStorage is provided: Stores tokens for automatic management
-	* - If tokenStorage is not provided: Only stores access token for manual management
-	*/
-	async setTokens(accessToken, refreshToken) {
-		await this.catalog.setTokens(accessToken, refreshToken);
-		await this.cart.setTokens(accessToken, refreshToken);
-		await this.auth.setTokens(accessToken, refreshToken);
-		await this.customer.setTokens(accessToken, refreshToken);
-		await this.helpers.setTokens(accessToken, refreshToken);
-		await this.shipping.setTokens(accessToken, refreshToken);
-		await this.order.setTokens(accessToken, refreshToken);
-		await this.store.setTokens(accessToken, refreshToken);
-	}
-	/**
-	* Clear all authentication tokens from all clients
-	*
-	* Behavior:
-	* - If tokenStorage is provided: Clears both access and refresh tokens from storage
-	* - If tokenStorage is not provided: Clears the manual access token
-	*/
-	async clearTokens() {
-		await this.catalog.clearTokens();
-		await this.cart.clearTokens();
-		await this.auth.clearTokens();
-		await this.customer.clearTokens();
-		await this.helpers.clearTokens();
-		await this.shipping.clearTokens();
-		await this.order.clearTokens();
-		await this.store.clearTokens();
-	}
-	/**
-	* Set the API key for all clients
-	*
-	* @param apiKey - The API key to set
-	*/
-	setApiKey(apiKey) {
-		this.catalog.setApiKey(apiKey);
-		this.cart.setApiKey(apiKey);
-		this.auth.setApiKey(apiKey);
-		this.customer.setApiKey(apiKey);
-		this.helpers.setApiKey(apiKey);
-		this.shipping.setApiKey(apiKey);
-		this.order.setApiKey(apiKey);
-		this.store.setApiKey(apiKey);
-	}
-	/**
-	* Clear the API key from all clients
-	*/
-	clearApiKey() {
-		this.catalog.clearApiKey();
-		this.cart.clearApiKey();
-		this.auth.clearApiKey();
-		this.customer.clearApiKey();
-		this.helpers.clearApiKey();
-		this.shipping.clearApiKey();
-		this.order.clearApiKey();
-		this.store.clearApiKey();
-	}
-	/**
-	* Get the current access token if using token storage
-	*/
-	async getAccessToken() {
-		return await this.auth.getAuthorizationHeader().then((header) => header.startsWith("Bearer ") ? header.substring(7) : null);
-	}
-	/**
-	* Get user information from the current access token
-	*
-	* @returns User information extracted from JWT token, or null if no token or invalid token
-	*/
-	async getUserInfo() {
-		const token = await this.getAccessToken();
-		if (!token) return null;
-		return extractUserInfoFromToken(token);
-	}
-	/**
-	* Get the current user ID from the access token
-	*
-	* @returns User ID (ulid) or null if no token or invalid token
-	*/
-	async getUserId() {
-		const token = await this.getAccessToken();
-		if (!token) return null;
-		return getUserIdFromToken(token);
-	}
-	/**
-	* Check if the current user is logged in (not anonymous)
-	*
-	* @returns True if user is logged in, false if anonymous or no token
-	*/
-	async isLoggedIn() {
-		const token = await this.getAccessToken();
-		if (!token) return false;
-		return isUserLoggedIn(token);
-	}
-	/**
-	* Check if the current user is anonymous
-	*
-	* @returns True if user is anonymous or no token, false if logged in
-	*/
-	async isAnonymous() {
-		const token = await this.getAccessToken();
-		if (!token) return true;
-		return isUserAnonymous(token);
-	}
-	/**
-	* Get the customer ID from the current access token
-	*
-	* @returns Customer ID or null if no token, invalid token, or user has no customer ID
-	*/
-	async getCustomerId() {
-		const userInfo = await this.getUserInfo();
-		return userInfo?.customerId || null;
-	}
-	/**
-	* Get the customer group ID from the current access token
-	*
-	* @returns Customer group ID or null if no token, invalid token, or user has no customer group
-	*/
-	async getCustomerGroupId() {
-		const userInfo = await this.getUserInfo();
-		return userInfo?.customerGroupId || null;
-	}
-	/**
-	* Set default headers for all clients
-	*
-	* @param headers - Default headers to set (only supported headers allowed)
-	*/
-	setDefaultHeaders(headers) {
-		const newConfig = {
-			...this.catalog["config"],
-			defaultHeaders: headers
-		};
-		this.catalog["config"] = newConfig;
-		this.cart["config"] = newConfig;
-		this.auth["config"] = newConfig;
-		this.customer["config"] = newConfig;
-		this.helpers["config"] = newConfig;
-		this.shipping["config"] = newConfig;
-		this.order["config"] = newConfig;
-		this.store["config"] = newConfig;
-	}
-	/**
-	* Get current default headers
-	*
-	* @returns Current default headers
-	*/
-	getDefaultHeaders() {
-		return this.catalog["config"].defaultHeaders;
-	}
-};
-var src_default = StorefrontSDK;
-
-//#endregion
-exports.AuthClient = AuthClient;
-exports.BrowserTokenStorage = BrowserTokenStorage;
-exports.CartClient = CartClient;
-exports.CatalogClient = CatalogClient;
-exports.CookieTokenStorage = CookieTokenStorage;
-exports.CustomerClient = CustomerClient;
-exports.Environment = Environment;
-exports.HelpersClient = HelpersClient;
-exports.MemoryTokenStorage = MemoryTokenStorage;
-exports.OrderClient = OrderClient;
-exports.ResponseUtils = ResponseUtils;
-exports.ShippingClient = ShippingClient;
-exports.StoreConfigClient = StoreConfigClient;
-exports.StorefrontAPIClient = StorefrontAPIClient;
-exports.StorefrontSDK = StorefrontSDK;
-exports.default = src_default;
-//# sourceMappingURL=index.cjs.map