@commercengine/pos 0.1.0

package/dist/index.js

@@ -0,0 +1,1152 @@
+import { BaseAPIClient, ResponseUtils, getPathnameFromUrl } from "@commercengine/sdk-core";
+import { decodeJwt } from "jose";
+
+//#region src/lib/utils/jwt.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 = decodeJwt(token);
+		return {
+			id: payload.ulid,
+			username: payload.username,
+			email: payload.email,
+			phone: payload.phone,
+			firstName: payload.first_name,
+			lastName: payload.last_name,
+			storeId: payload.store_id,
+			isLoggedIn: payload.is_logged_in,
+			customerId: payload.customer_id,
+			customerGroupId: payload.customer_group_id,
+			device: {
+				deviceId: payload.device.device_id,
+				deviceName: payload.device.device_name
+			},
+			location: {
+				id: payload.location.id,
+				name: payload.location.name
+			},
+			role: {
+				id: payload.role.id,
+				name: payload.role.name
+			},
+			tenantId: payload.tenant_id,
+			channel: {
+				id: payload.channel.id,
+				name: payload.channel.name,
+				type: payload.channel.type
+			},
+			sessionId: payload.sid,
+			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 = 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 authenticated (has valid POS token)
+* Checks the token for isLoggedIn status
+*
+* @param token - The JWT token
+* @returns True if user is authenticated with valid POS access
+*/
+function isUserAuthenticated(token) {
+	const userInfo = extractUserInfoFromToken(token);
+	return !!userInfo?.isLoggedIn;
+}
+/**
+* Get the device ID from a POS JWT token
+*
+* @param token - The JWT token
+* @returns Device ID or null if token is invalid
+*/
+function getDeviceIdFromToken(token) {
+	const userInfo = extractUserInfoFromToken(token);
+	return userInfo?.device?.deviceId || null;
+}
+/**
+* Get the location ID from a POS JWT token
+*
+* @param token - The JWT token
+* @returns Location ID or null if token is invalid
+*/
+function getLocationIdFromToken(token) {
+	const userInfo = extractUserInfoFromToken(token);
+	return userInfo?.location?.id || null;
+}
+/**
+* Get the role information from a POS JWT token
+*
+* @param token - The JWT token
+* @returns Role object with id and name, or null if token is invalid
+*/
+function getRoleFromToken(token) {
+	const userInfo = extractUserInfoFromToken(token);
+	return userInfo?.role || null;
+}
+/**
+* Get the tenant ID from a POS JWT token
+*
+* @param token - The JWT token
+* @returns Tenant ID or null if token is invalid
+*/
+function getTenantIdFromToken(token) {
+	const userInfo = extractUserInfoFromToken(token);
+	return userInfo?.tenantId || null;
+}
+
+//#endregion
+//#region src/lib/utils/auth.ts
+/**
+* Check if a URL path is a POS login endpoint that should use API key
+* Based on POS spec, only these 5 endpoints use X-Api-Key:
+* - /pos/auth/login/email
+* - /pos/auth/login/phone
+* - /pos/auth/login/whatsapp
+* - /pos/auth/pair-device
+* - /pos/auth/verify-otp
+*/
+function isApiKeyEndpoint(pathname) {
+	const apiKeyEndpoints = [
+		"/pos/auth/login/email",
+		"/pos/auth/login/phone",
+		"/pos/auth/login/whatsapp",
+		"/pos/auth/pair-device",
+		"/pos/auth/verify-otp"
+	];
+	return apiKeyEndpoints.some((endpoint) => pathname.includes(endpoint));
+}
+/**
+* Check if a URL path is a POS endpoint that returns tokens
+* Based on POS spec, only these endpoints return tokens:
+* - /pos/auth/verify-otp (after OTP verification)
+* - /pos/auth/refresh-token
+*/
+function isTokenReturningEndpoint(pathname) {
+	const tokenEndpoints = ["/pos/auth/verify-otp", "/pos/auth/refresh-token"];
+	return tokenEndpoints.some((endpoint) => pathname.includes(endpoint));
+}
+/**
+* Check if a URL path is a POS logout endpoint
+*/
+function isLogoutEndpoint(pathname) {
+	return pathname.includes("/pos/auth/logout") || pathname.includes("/pos/logout");
+}
+
+//#endregion
+//#region src/lib/middleware/auth.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 for POS
+*/
+var BrowserTokenStorage = class {
+	accessTokenKey;
+	refreshTokenKey;
+	constructor(prefix = "pos_") {
+		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);
+		}
+	}
+};
+/**
+* Create POS authentication middleware for openapi-fetch
+*
+* POS Authentication Rules:
+* 1. API Key endpoints (X-Api-Key): login/email, login/phone, login/whatsapp, pair-device, verify-otp
+* 2. Bearer token endpoints: All other endpoints
+* 3. Token returning endpoints: verify-otp, refresh-token
+*/
+function createPosAuthMiddleware(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 && !isTokenExpired(accessToken)) return;
+			if (!accessToken && refreshToken) {
+				await config.tokenStorage.clearTokens();
+				config.onTokensCleared?.();
+				console.info("Cleaned up orphaned refresh token in POS");
+				return;
+			}
+			if (accessToken && refreshToken && !isTokenExpired(refreshToken)) {
+				try {
+					await refreshTokens();
+					console.info("POS tokens refreshed proactively on startup");
+				} catch (error) {
+					await config.tokenStorage.clearTokens();
+					config.onTokensCleared?.();
+					console.info("POS tokens cleared after failed refresh on startup");
+				}
+				return;
+			}
+			if (accessToken && isTokenExpired(accessToken) || refreshToken && isTokenExpired(refreshToken)) {
+				await config.tokenStorage.clearTokens();
+				config.onTokensCleared?.();
+				console.info("POS stale tokens cleared on startup - user needs to re-authenticate");
+				return;
+			}
+			if (!accessToken && !refreshToken) return;
+		} catch (error) {
+			console.warn("POS token state assessment failed:", error);
+		}
+	};
+	const refreshTokens = async () => {
+		if (isRefreshing && refreshPromise) return refreshPromise;
+		isRefreshing = true;
+		refreshPromise = (async () => {
+			try {
+				const refreshToken = await config.tokenStorage.getRefreshToken();
+				if (!refreshToken || isTokenExpired(refreshToken)) throw new Error("No valid refresh token available");
+				let newTokens;
+				if (config.refreshTokenFn) newTokens = await config.refreshTokenFn(refreshToken);
+				else {
+					const response = await fetch(`${config.baseUrl}/pos/auth/refresh-token`, {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							Authorization: `Bearer ${await config.tokenStorage.getAccessToken()}`
+						},
+						body: JSON.stringify({ refresh_token: refreshToken })
+					});
+					if (!response.ok) throw new Error(`POS token refresh failed: ${response.status}`);
+					const data = await response.json();
+					newTokens = data.content || data;
+				}
+				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("POS 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 (isApiKeyEndpoint(pathname)) {
+				request.headers.set("X-Api-Key", config.apiKey);
+				return request;
+			}
+			let accessToken = await config.tokenStorage.getAccessToken();
+			if (accessToken && isTokenExpired(accessToken)) try {
+				await refreshTokens();
+				accessToken = await config.tokenStorage.getAccessToken();
+			} catch (error) {
+				console.warn("Token refresh failed:", error);
+				accessToken = null;
+			}
+			if (accessToken) request.headers.set("Authorization", `Bearer ${accessToken}`);
+			return request;
+		},
+		async onResponse({ request, response }) {
+			const pathname = getPathnameFromUrl(request.url);
+			if (response.ok && isTokenReturningEndpoint(pathname)) try {
+				const data = await response.clone().json();
+				const content = data.content || data;
+				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 POS response:", error);
+			}
+			else if (response.ok && isLogoutEndpoint(pathname)) {
+				await config.tokenStorage.clearTokens();
+				config.onTokensCleared?.();
+			}
+			if (response.status === 401 && !isApiKeyEndpoint(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("POS token refresh failed on 401 response:", error);
+				}
+			}
+			return response;
+		}
+	};
+}
+/**
+* Helper function to create POS auth middleware with sensible defaults
+*/
+function createDefaultPosAuthMiddleware(options) {
+	const tokenStorage = options.tokenStorage || (typeof localStorage !== "undefined" ? new BrowserTokenStorage() : new MemoryTokenStorage());
+	return createPosAuthMiddleware({
+		tokenStorage,
+		apiKey: options.apiKey,
+		baseUrl: options.baseUrl,
+		onTokensUpdated: options.onTokensUpdated,
+		onTokensCleared: options.onTokensCleared
+	});
+}
+
+//#endregion
+//#region src/lib/utils/url.ts
+/**
+* Environment configuration for POS API
+*/
+let Environment = /* @__PURE__ */ function(Environment$1) {
+	Environment$1["Development"] = "dev";
+	Environment$1["Staging"] = "staging";
+	Environment$1["Production"] = "production";
+	return Environment$1;
+}({});
+/**
+* Build the base URL for POS API requests
+*
+* @param config - URL configuration
+* @returns The base URL for POS API requests
+*/
+function buildPosURL(config) {
+	if (config.baseUrl) return config.baseUrl.replace(/\/$/, "");
+	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`;
+	}
+}
+
+//#endregion
+//#region src/lib/client.ts
+/**
+* POS API client that extends the generic BaseAPIClient
+* Adds Commerce Engine POS specific authentication and token management
+*/
+var PosAPIClient = class PosAPIClient extends BaseAPIClient {
+	config;
+	initializationPromise = null;
+	/**
+	* Validate required configuration parameters
+	* @param config - Configuration to validate
+	* @throws Error with descriptive message if validation fails
+	*/
+	static validateConfig(config) {
+		const errors = [];
+		if (!config.storeId?.trim()) errors.push("storeId is required and cannot be empty");
+		if (!config.apiKey?.trim()) errors.push("apiKey is required for POS authentication (needed for login, device pairing, and token refresh fallbacks)");
+		if (config.accessToken && !config.tokenStorage && !config.refreshToken) errors.push("When providing accessToken without tokenStorage, consider providing refreshToken for token refresh capability");
+		if (config.refreshToken && !config.accessToken) errors.push("refreshToken cannot be provided without accessToken (orphaned refresh token)");
+		if (config.refreshToken && !config.tokenStorage) errors.push("refreshToken requires tokenStorage for automatic token management");
+		if ((config.onTokensUpdated || config.onTokensCleared) && !config.tokenStorage) errors.push("Token callbacks (onTokensUpdated/onTokensCleared) require tokenStorage for automatic token management");
+		if (config.baseUrl && !PosAPIClient.isValidUrl(config.baseUrl)) errors.push("baseUrl must be a valid HTTP/HTTPS URL");
+		if (errors.length > 0) throw new Error(`POS SDK configuration validation failed:\n- ${errors.join("\n- ")}`);
+	}
+	/**
+	* Check if a string is a valid URL
+	* @param url - URL string to validate
+	* @returns True if valid URL
+	*/
+	static isValidUrl(url) {
+		try {
+			const parsed = new URL(url);
+			return parsed.protocol === "http:" || parsed.protocol === "https:";
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Create a new PosAPIClient
+	*
+	* @param config - Configuration for the API client
+	*/
+	constructor(config) {
+		PosAPIClient.validateConfig(config);
+		const baseUrl = buildPosURL({
+			storeId: config.storeId,
+			environment: config.environment,
+			baseUrl: config.baseUrl
+		});
+		const headerTransformations = { customer_group_id: "x-customer-group-id" };
+		super({
+			baseUrl,
+			timeout: config.timeout,
+			defaultHeaders: config.defaultHeaders,
+			debug: config.debug,
+			logger: config.logger
+		}, baseUrl, headerTransformations);
+		this.config = { ...config };
+		this.setupPosAuth();
+	}
+	/**
+	* Set up POS-specific authentication middleware
+	*/
+	setupPosAuth() {
+		const config = this.config;
+		if (config.tokenStorage) {
+			const authMiddleware = createDefaultPosAuthMiddleware({
+				apiKey: config.apiKey,
+				baseUrl: this.getBaseUrl(),
+				tokenStorage: config.tokenStorage,
+				onTokensUpdated: config.onTokensUpdated,
+				onTokensCleared: config.onTokensCleared
+			});
+			this.client.use(authMiddleware);
+			if (config.accessToken) {
+				this.initializationPromise = this.initializeTokens(config.accessToken, config.refreshToken);
+				config.accessToken = void 0;
+				config.refreshToken = void 0;
+			}
+		} else this.client.use({ onRequest: async ({ request }) => {
+			const pathname = getPathnameFromUrl(request.url);
+			if (isApiKeyEndpoint(pathname)) {
+				request.headers.set("X-Api-Key", config.apiKey);
+				return request;
+			}
+			if (config.accessToken) request.headers.set("Authorization", `Bearer ${config.accessToken}`);
+			else if (config.apiKey) request.headers.set("X-Api-Key", config.apiKey);
+			return request;
+		} });
+	}
+	/**
+	* 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;
+	}
+	/**
+	* 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);
+		}
+	}
+};
+
+//#endregion
+//#region src/lib/pos.ts
+/**
+* Client for interacting with POS endpoints
+* Single client that handles all POS operations including auth, cart, orders, etc.
+*/
+var PosClient = class extends PosAPIClient {
+	/**
+	* Login with email address for POS device
+	* @param body - Login credentials containing device ID and email
+	* @returns Promise with OTP token and action
+	*/
+	async loginWithEmail(body) {
+		return this.executeRequest(() => this.client.POST("/pos/auth/login/email", { body }));
+	}
+	/**
+	* Login with phone number for POS device
+	* @param body - Login credentials containing device ID and phone
+	* @returns Promise with OTP token and action
+	*/
+	async loginWithPhone(body) {
+		return this.executeRequest(() => this.client.POST("/pos/auth/login/phone", { body }));
+	}
+	/**
+	* Login with WhatsApp for POS device
+	* @param body - Login credentials containing device ID and phone
+	* @returns Promise with OTP token and action
+	*/
+	async loginWithWhatsapp(body) {
+		return this.executeRequest(() => this.client.POST("/pos/auth/login/whatsapp", { body }));
+	}
+	/**
+	* Pair POS device with pairing code
+	* @param body - Pairing code received via phone/email
+	* @returns Promise with device information
+	*/
+	async pairDevice(body) {
+		return this.executeRequest(() => this.client.POST("/pos/auth/pair-device", { body }));
+	}
+	/**
+	* Verify OTP for POS login
+	* @param body - OTP verification data
+	* @returns Promise with user info and tokens
+	*/
+	async verifyOtp(body) {
+		return this.executeRequest(() => this.client.POST("/pos/auth/verify-otp", { body }));
+	}
+	/**
+	* Refresh POS access token
+	* @param body - Refresh token data
+	* @returns Promise with new tokens
+	*/
+	async refreshAccessToken(body) {
+		return this.executeRequest(() => this.client.POST("/pos/auth/refresh-token", { body }));
+	}
+	/**
+	* Logout from POS device
+	* @returns Promise with logout confirmation
+	*/
+	async logout() {
+		return this.executeRequest(() => this.client.POST("/pos/auth/logout"));
+	}
+	/**
+	* Create a new cart
+	* @param body - Cart creation data with items
+	* @returns Promise with created cart
+	*/
+	async createCart(body) {
+		return this.executeRequest(() => this.client.POST("/pos/carts", { body }));
+	}
+	/**
+	* Get cart details
+	* @param pathParams - Cart ID
+	* @returns Promise with cart details
+	*/
+	async getCart(pathParams) {
+		return this.executeRequest(() => this.client.GET("/pos/carts/{id}", { params: { path: pathParams } }));
+	}
+	/**
+	* Delete cart (remove all items)
+	* @param pathParams - Cart ID
+	* @returns Promise with deletion confirmation
+	*/
+	async deleteCart(pathParams) {
+		return this.executeRequest(() => this.client.DELETE("/pos/carts/{id}", { params: { path: pathParams } }));
+	}
+	/**
+	* Add/update cart item (set quantity to 0 to remove)
+	* @param pathParams - Cart ID
+	* @param body - Item update data
+	* @returns Promise with updated cart
+	*/
+	async updateCart(pathParams, body) {
+		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/items", {
+			params: { path: pathParams },
+			body
+		}));
+	}
+	/**
+	* Update cart address (billing/shipping)
+	* @param pathParams - Cart ID
+	* @param body - Address data (registered user IDs or guest addresses)
+	* @returns Promise with updated cart
+	*/
+	async createCartAddress(pathParams, body) {
+		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/address", {
+			params: { path: pathParams },
+			body
+		}));
+	}
+	/**
+	* List all available coupons
+	* @param headers - Optional header parameters (customer_group_id, etc.)
+	* @returns Promise with available coupons
+	*/
+	async listCoupons(headers) {
+		const mergedHeaders = this.mergeHeaders(headers);
+		return this.executeRequest(() => this.client.GET("/pos/carts/available-coupons", { params: { header: mergedHeaders } }));
+	}
+	/**
+	* List all available promotions
+	* @param headers - Optional header parameters (customer_group_id, etc.)
+	* @returns Promise with available promotions
+	*/
+	async listPromotions(headers) {
+		const mergedHeaders = this.mergeHeaders(headers);
+		return this.executeRequest(() => this.client.GET("/pos/carts/available-promotions", { params: { header: mergedHeaders } }));
+	}
+	/**
+	* Apply coupon to cart
+	* @param pathParams - Cart ID
+	* @param body - Coupon code
+	* @returns Promise with updated cart
+	*/
+	async applyCoupon(pathParams, body) {
+		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/coupon", {
+			params: { path: pathParams },
+			body
+		}));
+	}
+	/**
+	* Remove coupon from cart
+	* @param pathParams - Cart ID
+	* @returns Promise with updated cart
+	*/
+	async removeCoupon(pathParams) {
+		return this.executeRequest(() => this.client.DELETE("/pos/carts/{id}/coupon", { params: { path: pathParams } }));
+	}
+	/**
+	* Evaluate applicable/inapplicable coupons for cart
+	* @param pathParams - Cart ID
+	* @returns Promise with coupon evaluation results
+	*/
+	async evaluateCoupons(pathParams) {
+		return this.executeRequest(() => this.client.GET("/pos/carts/{id}/evaluate-coupons", { params: { path: pathParams } }));
+	}
+	/**
+	* Evaluate applicable/inapplicable promotions for cart
+	* @param pathParams - Cart ID
+	* @returns Promise with promotion evaluation results
+	*/
+	async evaluatePromotions(pathParams) {
+		return this.executeRequest(() => this.client.GET("/pos/carts/{id}/evaluate-promotions", { params: { path: pathParams } }));
+	}
+	/**
+	* Apply credit balance to cart
+	* @param pathParams - Cart ID
+	* @param body - Credit balance amount to use
+	* @returns Promise with updated cart
+	*/
+	async redeemCreditBalance(pathParams, body) {
+		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/credit-balance", {
+			params: { path: pathParams },
+			body
+		}));
+	}
+	/**
+	* Remove credit balance from cart
+	* @param pathParams - Cart ID
+	* @returns Promise with updated cart
+	*/
+	async removeCreditBalance(pathParams) {
+		return this.executeRequest(() => this.client.DELETE("/pos/carts/{id}/credit-balance", { params: { path: pathParams } }));
+	}
+	/**
+	* Redeem gift card for cart
+	* @param pathParams - Cart ID
+	* @param body - Gift card code
+	* @returns Promise with updated cart
+	*/
+	async redeemGiftCard(pathParams, body) {
+		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/gift-card", {
+			params: { path: pathParams },
+			body
+		}));
+	}
+	/**
+	* Remove gift card from cart
+	* @param pathParams - Cart ID
+	* @returns Promise with updated cart
+	*/
+	async removeGiftCard(pathParams) {
+		return this.executeRequest(() => this.client.DELETE("/pos/carts/{id}/gift-card", { params: { path: pathParams } }));
+	}
+	/**
+	* Redeem loyalty points for cart
+	* @param pathParams - Cart ID
+	* @param body - Loyalty points to redeem
+	* @returns Promise with updated cart
+	*/
+	async redeemLoyaltyPoints(pathParams, body) {
+		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/loyalty-points", {
+			params: { path: pathParams },
+			body
+		}));
+	}
+	/**
+	* Remove loyalty points from cart
+	* @param pathParams - Cart ID
+	* @returns Promise with updated cart
+	*/
+	async removeLoyaltyPoints(pathParams) {
+		return this.executeRequest(() => this.client.DELETE("/pos/carts/{id}/loyalty-points", { params: { path: pathParams } }));
+	}
+	/**
+	* Update cart fulfillment preference (delivery/pickup)
+	* @param pathParams - Cart ID
+	* @param body - Fulfillment preference data
+	* @returns Promise with confirmation
+	*/
+	async updateFulfillmentPreference(pathParams, body) {
+		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/fulfillment-preference", {
+			params: { path: pathParams },
+			body
+		}));
+	}
+	/**
+	* Get fulfillment options for cart
+	* @param body - Cart data for fulfillment calculation
+	* @returns Promise with fulfillment options
+	*/
+	async getFulfillmentOptions(body) {
+		return this.executeRequest(() => this.client.POST("/pos/fulfillment-options", { body }));
+	}
+	/**
+	* Update cart customer information
+	* @param pathParams - Cart ID
+	* @param body - Customer update data
+	* @returns Promise with updated cart
+	*/
+	async updateCartCustomer(pathParams, body) {
+		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/update-customer", {
+			params: { path: pathParams },
+			body
+		}));
+	}
+	/**
+	* Create order from cart
+	* @param body - Order creation data
+	* @returns Promise with created order
+	*/
+	async createOrder(body) {
+		return this.executeRequest(() => this.client.POST("/pos/orders", { body }));
+	}
+	/**
+	* List all categories
+	* @param query - Optional query parameters for filtering categories
+	* @returns Promise with list of categories
+	*/
+	async listCategories(query) {
+		return this.executeRequest(() => this.client.GET("/pos/catalog/categories", { params: { query } }));
+	}
+	/**
+	* List all products
+	* @param query - Optional query parameters for filtering products
+	* @param headers - Optional header parameters
+	* @returns Promise with list of products
+	*/
+	async listProducts(query, headers) {
+		const mergedHeaders = this.mergeHeaders(headers);
+		return this.executeRequest(() => this.client.GET("/pos/catalog/products", { params: {
+			query,
+			header: mergedHeaders
+		} }));
+	}
+	/**
+	* List cross-sell products
+	* @param query - Query parameters with product IDs for cross-sell recommendations
+	* @param headers - Optional header parameters
+	* @returns Promise with cross-sell products
+	*/
+	async listCrosssellProducts(query, headers) {
+		const mergedHeaders = this.mergeHeaders(headers);
+		return this.executeRequest(() => this.client.GET("/pos/catalog/products/cross-sell", { params: {
+			query,
+			header: mergedHeaders
+		} }));
+	}
+	/**
+	* Search products
+	* @param body - Search criteria and parameters
+	* @param headers - Optional header parameters
+	* @returns Promise with search results
+	*/
+	async searchProducts(body, headers) {
+		const mergedHeaders = this.mergeHeaders(headers);
+		return this.executeRequest(() => this.client.POST("/pos/catalog/products/search", {
+			body,
+			params: { header: mergedHeaders }
+		}));
+	}
+	/**
+	* List similar products
+	* @param query - Query parameters with product ID for similarity recommendations
+	* @param headers - Optional header parameters
+	* @returns Promise with similar products
+	*/
+	async listSimilarProducts(query, headers) {
+		const mergedHeaders = this.mergeHeaders(headers);
+		return this.executeRequest(() => this.client.GET("/pos/catalog/products/similar", { params: {
+			query,
+			header: mergedHeaders
+		} }));
+	}
+	/**
+	* List up-sell products
+	* @param query - Query parameters with product IDs for up-sell recommendations
+	* @param headers - Optional header parameters
+	* @returns Promise with up-sell products
+	*/
+	async listUpsellProducts(query, headers) {
+		const mergedHeaders = this.mergeHeaders(headers);
+		return this.executeRequest(() => this.client.GET("/pos/catalog/products/up-sell", { params: {
+			query,
+			header: mergedHeaders
+		} }));
+	}
+	/**
+	* Get product details
+	* @param pathParams - Product ID or slug
+	* @param headers - Optional header parameters
+	* @returns Promise with product details
+	*/
+	async getProductDetail(pathParams, headers) {
+		const mergedHeaders = this.mergeHeaders(headers);
+		return this.executeRequest(() => this.client.GET("/pos/catalog/products/{product_id_or_slug}", { params: {
+			path: pathParams,
+			header: mergedHeaders
+		} }));
+	}
+	/**
+	* List product reviews
+	* @param pathParams - Product ID
+	* @param query - Optional query parameters for filtering reviews
+	* @returns Promise with product reviews
+	*/
+	async listProductReviews(pathParams, query) {
+		return this.executeRequest(() => this.client.GET("/pos/catalog/products/{product_id}/reviews", { params: {
+			path: pathParams,
+			query
+		} }));
+	}
+	/**
+	* List product variants
+	* @param pathParams - Product ID
+	* @param headers - Optional header parameters
+	* @returns Promise with product variants
+	*/
+	async listProductVariants(pathParams, headers) {
+		const mergedHeaders = this.mergeHeaders(headers);
+		return this.executeRequest(() => this.client.GET("/pos/catalog/products/{product_id}/variants", { params: {
+			path: pathParams,
+			header: mergedHeaders
+		} }));
+	}
+	/**
+	* Get variant details
+	* @param pathParams - Product ID and variant ID
+	* @param headers - Optional header parameters
+	* @returns Promise with variant details
+	*/
+	async getVariantDetail(pathParams, headers) {
+		const mergedHeaders = this.mergeHeaders(headers);
+		return this.executeRequest(() => this.client.GET("/pos/catalog/products/{product_id}/variants/{variant_id}", { params: {
+			path: pathParams,
+			header: mergedHeaders
+		} }));
+	}
+	/**
+	* List all SKUs
+	* @param query - Optional query parameters for filtering SKUs
+	* @param headers - Optional header parameters
+	* @returns Promise with list of SKUs
+	*/
+	async listSkus(query, headers) {
+		const mergedHeaders = this.mergeHeaders(headers);
+		return this.executeRequest(() => this.client.GET("/pos/catalog/skus", { params: {
+			query,
+			header: mergedHeaders
+		} }));
+	}
+};
+
+//#endregion
+//#region src/index.ts
+/**
+* Main SDK class for the POS API
+* Provides access to all POS endpoints through a single client
+*/
+var PosSDK = class {
+	/**
+	* Client for all POS operations (auth, cart, orders, etc.)
+	*/
+	pos;
+	/**
+	* Create a new PosSDK 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.pos = new PosClient(config);
+	}
+	/**
+	* Set authentication tokens for the client
+	*
+	* @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.pos.setTokens(accessToken, refreshToken);
+	}
+	/**
+	* Clear all authentication tokens from the client
+	*
+	* 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.pos.clearTokens();
+	}
+	/**
+	* Set the API key for the client
+	*
+	* @param apiKey - The API key to set
+	*/
+	setApiKey(apiKey) {
+		this.pos.setApiKey(apiKey);
+	}
+	/**
+	* Get the current access token if available
+	*/
+	async getAccessToken() {
+		const header = await this.pos.getAuthorizationHeader();
+		return header.startsWith("Bearer ") ? header.substring(7) : null;
+	}
+	/**
+	* Set default headers for the client
+	*
+	* @param headers - Default headers to set
+	*/
+	setDefaultHeaders(headers) {
+		this.pos.setDefaultHeaders(headers);
+	}
+	/**
+	* Get current default headers
+	*/
+	getDefaultHeaders() {
+		return this.pos.getDefaultHeaders();
+	}
+	/**
+	* 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
+	*
+	* @returns True if user is logged in, false otherwise
+	*/
+	async isLoggedIn() {
+		const token = await this.getAccessToken();
+		if (!token) return false;
+		return isUserLoggedIn(token);
+	}
+	/**
+	* Check if the current user is authenticated with POS access
+	* This verifies the user has valid device and role information
+	*
+	* @returns True if user is authenticated for POS operations
+	*/
+	async isAuthenticated() {
+		const token = await this.getAccessToken();
+		if (!token) return false;
+		return isUserAuthenticated(token);
+	}
+	/**
+	* Get the device ID from the current access token
+	* This is commonly needed for POS API requests
+	*
+	* @returns Device ID or null if no token or invalid token
+	*/
+	async getDeviceId() {
+		const token = await this.getAccessToken();
+		if (!token) return null;
+		return getDeviceIdFromToken(token);
+	}
+	/**
+	* Get the location ID from the current access token
+	* This is commonly needed for POS API requests
+	*
+	* @returns Location ID or null if no token or invalid token
+	*/
+	async getLocationId() {
+		const token = await this.getAccessToken();
+		if (!token) return null;
+		return getLocationIdFromToken(token);
+	}
+	/**
+	* Get the role information from the current access token
+	*
+	* @returns Role object with id and name, or null if no token or invalid token
+	*/
+	async getRole() {
+		const token = await this.getAccessToken();
+		if (!token) return null;
+		return getRoleFromToken(token);
+	}
+	/**
+	* Get the tenant ID from the current access token
+	*
+	* @returns Tenant ID or null if no token or invalid token
+	*/
+	async getTenantId() {
+		const token = await this.getAccessToken();
+		if (!token) return null;
+		return getTenantIdFromToken(token);
+	}
+};
+var src_default = PosSDK;
+
+//#endregion
+export { BrowserTokenStorage, Environment, MemoryTokenStorage, PosAPIClient, PosClient, PosSDK, ResponseUtils, src_default as default };
+//# sourceMappingURL=index.js.map