@commercengine/pos 0.1.3 → 0.3.0

package/dist/index.js

@@ -395,6 +395,15 @@ var BaseAPIClient = class {
 	getDefaultHeaders() {
 		return this.config.defaultHeaders;
 	}
+	/**
+	* Add middleware to the client
+	* This allows SDK extensions to add custom middleware like authentication
+	*
+	* @param middleware - Middleware to add to the client
+	*/
+	use(middleware) {
+		this.client.use(middleware);
+	}
 };
 /**
 * Generic URL utility functions for any SDK
@@ -982,6 +991,20 @@ var PosAPIClient = class PosAPIClient extends BaseAPIClient {
 			console.warn("Failed to initialize tokens in storage:", error);
 		}
 	}
+	/**
+	* Get client typed for storefront POS operations (paths schema)
+	* This provides proper typing for storefront POS endpoints
+	*/
+	get storefrontClient() {
+		return this.client;
+	}
+	/**
+	* Get client typed for admin POS operations (AdminPaths schema)
+	* This provides proper typing for admin POS endpoints
+	*/
+	get adminClient() {
+		return this.client;
+	}
 };
 
 //#endregion
@@ -992,41 +1015,97 @@ var PosAPIClient = class PosAPIClient extends BaseAPIClient {
 */
 var PosClient = class extends PosAPIClient {
 	/**
-	* Login with email address for POS device
-	* @param body - Login credentials containing device ID and email
+	* Login with email address
+	* @param body - Login credentials containing location ID and email
 	* @returns Promise with OTP token and action
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.loginWithEmail({
+	*   location_id: "pos-location-123",
+	*   email: "staff@example.com"
+	* });
+	*
+	* if (error) {
+	*   console.error("Login failed:", error.message);
+	* } else {
+	*   console.log("OTP sent:", data.otp_token);
+	*   console.log("Action:", data.otp_action);
+	*   // Use the otp_token to verify OTP
+	* }
+	* ```
 	*/
 	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
+	* Login with phone number
+	* @param body - Login credentials containing location ID and phone
 	* @returns Promise with OTP token and action
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.loginWithPhone({
+	*   location_id: "pos-location-123",
+	*   phone: "234567890",
+	*   country_code: "+91" // default is +91
+	* });
+	*
+	* if (error) {
+	*   console.error("Login failed:", error.message);
+	* } else {
+	*   console.log("OTP sent:", data.otp_token);
+	*   console.log("Action:", data.otp_action);
+	*   // Use the otp_token to verify OTP
+	* }
+	* ```
 	*/
 	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
+	* Login with WhatsApp
+	* @param body - Login credentials containing location ID and phone
 	* @returns Promise with OTP token and action
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.loginWithWhatsapp({
+	*   location_id: "pos-location-123",
+	*   phone: "234567890",
+	*   country_code: "+91" // default is +91
+	* });
+	*
+	* if (error) {
+	*   console.error("WhatsApp login failed:", error.message);
+	* } else {
+	*   console.log("WhatsApp OTP sent:", data.otp_token);
+	*   console.log("Action:", data.otp_action);
+	*   // Use the otp_token to verify OTP
+	* }
+	* ```
 	*/
 	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
+	* Verify OTP
 	* @param body - OTP verification data
 	* @returns Promise with user info and tokens
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.verifyOtp({
+	*   otp_token: "otp-token-from-login",
+	*   otp: "123456",
+	*   otp_action: "login"
+	* });
+	*
+	* if (error) {
+	*   console.error("OTP verification failed:", error.message);
+	* } else {
+	*   console.log("Login successful:", data.user);
+	*   console.log("Access token:", data.access_token);
+	*   console.log("Refresh token:", data.refresh_token);
+	*   // Tokens are automatically stored by the SDK
+	* }
+	* ```
 	*/
 	async verifyOtp(body) {
 		return this.executeRequest(() => this.client.POST("/pos/auth/verify-otp", { body }));
@@ -1035,21 +1114,169 @@ var PosClient = class extends PosAPIClient {
 	* Refresh POS access token
 	* @param body - Refresh token data
 	* @returns Promise with new tokens
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.refreshAccessToken({
+	*   refresh_token: "refresh-token-here"
+	* });
+	*
+	* if (error) {
+	*   console.error("Token refresh failed:", error.message);
+	* } else {
+	*   console.log("New access token:", data.access_token);
+	*   console.log("New refresh token:", data.refresh_token);
+	*   // New tokens are automatically stored by the SDK
+	* }
+	* ```
 	*/
 	async refreshAccessToken(body) {
 		return this.executeRequest(() => this.client.POST("/pos/auth/refresh-token", { body }));
 	}
 	/**
-	* Logout from POS device
+	* Logout
 	* @returns Promise with logout confirmation
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.logout();
+	*
+	* if (error) {
+	*   console.error("Logout failed:", error.message);
+	* } else {
+	*   console.log("Logout message:", data.message);
+	*   console.log("Success:", data.success);
+	*   // Tokens are automatically cleared by the SDK
+	* }
+	* ```
 	*/
 	async logout() {
 		return this.executeRequest(() => this.client.POST("/pos/auth/logout"));
 	}
 	/**
+	* List store locations
+	* @returns Promise with list of locations
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.listLocations();
+	* if (error) {
+	*   console.error("Failed to list locations:", error.message);
+	* } else {
+	*   console.log("Locations:", data.locations);
+	* }
+	* ```
+	*/
+	async listLocations() {
+		return this.executeRequest(() => this.client.GET("/pos/locations"));
+	}
+	/**
+	* List devices
+	* @returns Promise with list of devices
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.listDevices();
+	* if (error) {
+	*   console.error("Failed to list devices:", error.message);
+	* } else {
+	*   console.log("Devices:", data.devices);
+	* }
+	* ```
+	*/
+	async listDevices() {
+		return this.executeRequest(() => this.client.GET("/pos/devices"));
+	}
+	/**
+	* Pair POS device with pairing code
+	* @param body - Pairing code received via phone/email
+	* @returns Promise with device information
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.pairDevice({
+	*   pairing_code: "ABC123"
+	* });
+	*
+	* if (error) {
+	*   console.error("Device pairing failed:", error.message);
+	* } else {
+	*   console.log("Device paired:", data.device.id);
+	*   console.log("Device name:", data.device.name);
+	*   // Store device_id for future use
+	* }
+	* ```
+	*/
+	async pairDevice(body) {
+		return this.executeRequest(() => this.client.POST("/pos/auth/pair-device", { body }));
+	}
+	/**
+	* Unclaim POS device - Unlinks a device from the user session
+	* @param pathParams - Device ID
+	* @returns Promise with unclaim confirmation
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.unclaimDevice({
+	*   id: "01H9DEVICE12345ABCDE"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to unclaim device:", error.message);
+	* } else {
+	*   console.log("Device unclaimed:", data.message);
+	* }
+	* ```
+	*/
+	async unclaimDevice(pathParams) {
+		return this.executeRequest(() => this.client.POST("/pos/devices/{id}/unclaim", { params: { path: pathParams } }));
+	}
+	/**
+	* Claim POS device - Links a device to the user session
+	* @param pathParams - Device ID
+	* @returns Promise with claim confirmation
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.claimDevice({
+	*   id: "01H9DEVICE12345ABCDE"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to claim device:", error.message);
+	* } else {
+	*   console.log("Device claimed:", data.message);
+	* }
+	* ```
+	*/
+	async claimDevice(pathParams) {
+		return this.executeRequest(() => this.client.POST("/pos/devices/{id}/claim", { params: { path: pathParams } }));
+	}
+	/**
 	* Create a new cart
 	* @param body - Cart creation data with items
 	* @returns Promise with created cart
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.createCart({
+	*   items: [
+	*     {
+	*       product_id: "01H9XYZ12345ABCDE",
+	*       variant_id: null,
+	*       quantity: 2
+	*     },
+	*     {
+	*       product_id: "01H9ABC67890FGHIJ",
+	*       variant_id: "01H9XYZ67890KLMNO",
+	*       quantity: 1
+	*     }
+	*   ],
+	*   metadata: {
+	*     "source": "pos-terminal-1",
+	*     "staff_id": "staff-123"
+	*   }
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to create cart:", error.message);
+	* } else {
+	*   console.log("Cart created:", data.cart.id);
+	*   console.log("Cart total:", data.cart.grand_total);
+	* }
+	* ```
 	*/
 	async createCart(body) {
 		return this.executeRequest(() => this.client.POST("/pos/carts", { body }));
@@ -1058,6 +1285,20 @@ var PosClient = class extends PosAPIClient {
 	* Get cart details
 	* @param pathParams - Cart ID
 	* @returns Promise with cart details
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.getCart({
+	*   id: "01H9CART12345ABCDE"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to get cart:", error.message);
+	* } else {
+	*   const cart = data.cart;
+	*   console.log("Cart total:", cart.grand_total);
+	*   console.log("Items count:", cart.cart_items.length);
+	* }
+	* ```
 	*/
 	async getCart(pathParams) {
 		return this.executeRequest(() => this.client.GET("/pos/carts/{id}", { params: { path: pathParams } }));
@@ -1066,6 +1307,18 @@ var PosClient = class extends PosAPIClient {
 	* Delete cart (remove all items)
 	* @param pathParams - Cart ID
 	* @returns Promise with deletion confirmation
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.deleteCart({
+	*   id: "01H9CART12345ABCDE"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to delete cart:", error.message);
+	* } else {
+	*   console.log("Cart deleted:", data.message);
+	* }
+	* ```
 	*/
 	async deleteCart(pathParams) {
 		return this.executeRequest(() => this.client.DELETE("/pos/carts/{id}", { params: { path: pathParams } }));
@@ -1075,6 +1328,34 @@ var PosClient = class extends PosAPIClient {
 	* @param pathParams - Cart ID
 	* @param body - Item update data
 	* @returns Promise with updated cart
+	* @example
+	* ```typescript
+	* // Add item to cart
+	* const { data, error } = await pos.updateCart(
+	*   { 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.cart_items.length);
+	* }
+	*
+	* // Remove item from cart (set quantity to 0)
+	* const { data: removeData, error: removeError } = await pos.updateCart(
+	*   { id: "01H9CART12345ABCDE" },
+	*   {
+	*     product_id: "01H9XYZ12345ABCDE",
+	*     variant_id: null,
+	*     quantity: 0
+	*   }
+	* );
+	* ```
 	*/
 	async updateCart(pathParams, body) {
 		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/items", {
@@ -1087,6 +1368,62 @@ var PosClient = class extends PosAPIClient {
 	* @param pathParams - Cart ID
 	* @param body - Address data (registered user IDs or guest addresses)
 	* @returns Promise with updated cart
+	* @example
+	* ```typescript
+	* // For registered users with saved addresses
+	* const { data, error } = await pos.createCartAddress(
+	*   { 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 pos.createCartAddress(
+	*   { 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 createCartAddress(pathParams, body) {
 		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/address", {
@@ -1098,6 +1435,26 @@ var PosClient = class extends PosAPIClient {
 	* List all available coupons
 	* @param headers - Optional header parameters (customer_group_id, etc.)
 	* @returns Promise with available coupons
+	* @example
+	* ```typescript
+	* // Get all available coupons
+	* const { data, error } = await pos.listCoupons();
+	*
+	* 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 pos.listCoupons({
+	*   "x-customer-group-id": "01H9GROUP12345ABC" // Override default SDK config
+	* });
+	* ```
 	*/
 	async listCoupons(headers) {
 		const mergedHeaders = this.mergeHeaders(headers);
@@ -1107,6 +1464,26 @@ var PosClient = class extends PosAPIClient {
 	* List all available promotions
 	* @param headers - Optional header parameters (customer_group_id, etc.)
 	* @returns Promise with available promotions
+	* @example
+	* ```typescript
+	* // Get all available promotions
+	* const { data, error } = await pos.listPromotions();
+	*
+	* 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 pos.listPromotions({
+	*   "x-customer-group-id": "01H9GROUP12345ABC" // Override default SDK config
+	* });
+	* ```
 	*/
 	async listPromotions(headers) {
 		const mergedHeaders = this.mergeHeaders(headers);
@@ -1117,6 +1494,20 @@ var PosClient = class extends PosAPIClient {
 	* @param pathParams - Cart ID
 	* @param body - Coupon code
 	* @returns Promise with updated cart
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.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.grand_total);
+	*   console.log("Discount amount:", data.cart.coupon_discount_amount);
+	* }
+	* ```
 	*/
 	async applyCoupon(pathParams, body) {
 		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/coupon", {
@@ -1128,6 +1519,18 @@ var PosClient = class extends PosAPIClient {
 	* Remove coupon from cart
 	* @param pathParams - Cart ID
 	* @returns Promise with updated cart
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.removeCoupon({
+	*   id: "01H9CART12345ABCDE"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to remove coupon:", error.message);
+	* } else {
+	*   console.log("Coupon removed, new total:", data.cart.grand_total);
+	* }
+	* ```
 	*/
 	async removeCoupon(pathParams) {
 		return this.executeRequest(() => this.client.DELETE("/pos/carts/{id}/coupon", { params: { path: pathParams } }));
@@ -1136,6 +1539,29 @@ var PosClient = class extends PosAPIClient {
 	* Evaluate applicable/inapplicable coupons for cart
 	* @param pathParams - Cart ID
 	* @returns Promise with coupon evaluation results
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.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(pathParams) {
 		return this.executeRequest(() => this.client.GET("/pos/carts/{id}/evaluate-coupons", { params: { path: pathParams } }));
@@ -1144,6 +1570,29 @@ var PosClient = class extends PosAPIClient {
 	* Evaluate applicable/inapplicable promotions for cart
 	* @param pathParams - Cart ID
 	* @returns Promise with promotion evaluation results
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.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(pathParams) {
 		return this.executeRequest(() => this.client.GET("/pos/carts/{id}/evaluate-promotions", { params: { path: pathParams } }));
@@ -1153,6 +1602,20 @@ var PosClient = class extends PosAPIClient {
 	* @param pathParams - Cart ID
 	* @param body - Credit balance amount to use
 	* @returns Promise with updated cart
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.redeemCreditBalance(
+	*   { id: "01H9CART12345ABCDE" },
+	*   { credit_balance_used: 250.00 }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to redeem credit balance:", error.message);
+	* } else {
+	*   console.log("Credit applied, new total:", data.cart.grand_total);
+	*   console.log("Credit used:", data.cart.credit_balance_used);
+	* }
+	* ```
 	*/
 	async redeemCreditBalance(pathParams, body) {
 		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/credit-balance", {
@@ -1164,6 +1627,18 @@ var PosClient = class extends PosAPIClient {
 	* Remove credit balance from cart
 	* @param pathParams - Cart ID
 	* @returns Promise with updated cart
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.removeCreditBalance({
+	*   id: "01H9CART12345ABCDE"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to remove credit balance:", error.message);
+	* } else {
+	*   console.log("Credit balance removed, new total:", data.cart.grand_total);
+	* }
+	* ```
 	*/
 	async removeCreditBalance(pathParams) {
 		return this.executeRequest(() => this.client.DELETE("/pos/carts/{id}/credit-balance", { params: { path: pathParams } }));
@@ -1173,6 +1648,20 @@ var PosClient = class extends PosAPIClient {
 	* @param pathParams - Cart ID
 	* @param body - Loyalty points to redeem
 	* @returns Promise with updated cart
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.redeemLoyaltyPoints(
+	*   { id: "01H9CART12345ABCDE" },
+	*   { loyalty_point_redeemed: 500 }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to redeem loyalty points:", error.message);
+	* } else {
+	*   console.log("Points redeemed, new total:", data.cart.grand_total);
+	*   console.log("Points redeemed:", data.cart.loyalty_points_redeemed);
+	* }
+	* ```
 	*/
 	async redeemLoyaltyPoints(pathParams, body) {
 		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/loyalty-points", {
@@ -1184,6 +1673,18 @@ var PosClient = class extends PosAPIClient {
 	* Remove loyalty points from cart
 	* @param pathParams - Cart ID
 	* @returns Promise with updated cart
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.removeLoyaltyPoints({
+	*   id: "01H9CART12345ABCDE"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to remove loyalty points:", error.message);
+	* } else {
+	*   console.log("Loyalty points removed, new total:", data.cart.grand_total);
+	* }
+	* ```
 	*/
 	async removeLoyaltyPoints(pathParams) {
 		return this.executeRequest(() => this.client.DELETE("/pos/carts/{id}/loyalty-points", { params: { path: pathParams } }));
@@ -1193,6 +1694,23 @@ var PosClient = class extends PosAPIClient {
 	* @param pathParams - Cart ID
 	* @param body - Fulfillment preference data
 	* @returns Promise with confirmation
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.updateFulfillmentPreference(
+	*   { id: "01H9CART12345ABCDE" },
+	*   {
+	*     fulfillment_type: "delivery",
+	*     delivery_address_id: "01H9ADDR12345ABCDE"
+	*   }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to update fulfillment preference:", error.message);
+	* } else {
+	*   console.log("Fulfillment preference updated:", data.message);
+	*   console.log("Success:", data.success);
+	* }
+	* ```
 	*/
 	async updateFulfillmentPreference(pathParams, body) {
 		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/fulfillment-preference", {
@@ -1204,6 +1722,28 @@ var PosClient = class extends PosAPIClient {
 	* Get fulfillment options for cart
 	* @param body - Cart data for fulfillment calculation
 	* @returns Promise with fulfillment options
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.getFulfillmentOptions({
+	*   cart_id: "01H9CART12345ABCDE",
+	*   delivery_address: {
+	*     street: "123 Main St",
+	*     city: "New York",
+	*     state: "NY",
+	*     zip_code: "10001",
+	*     country: "US"
+	*   }
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to get fulfillment options:", error.message);
+	* } else {
+	*   console.log("Available fulfillment options:", data.options.length);
+	*   data.options.forEach(option => {
+	*     console.log(`${option.type}: ${option.name} - $${option.cost}`);
+	*   });
+	* }
+	* ```
 	*/
 	async getFulfillmentOptions(body) {
 		return this.executeRequest(() => this.client.POST("/pos/fulfillment-options", { body }));
@@ -1213,6 +1753,24 @@ var PosClient = class extends PosAPIClient {
 	* @param pathParams - Cart ID
 	* @param body - Customer update data
 	* @returns Promise with updated cart
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.updateCartCustomer(
+	*   { id: "01H9CART12345ABCDE" },
+	*   {
+	*     customer_id: "01H9CUST12345ABCDE",
+	*     customer_group_id: "01H9GROUP12345ABCDE"
+	*   }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to update cart customer:", error.message);
+	* } else {
+	*   console.log("Cart customer updated:", data.cart.id);
+	*   console.log("Customer ID:", data.cart.customer_id);
+	*   console.log("Customer group:", data.cart.customer_group_id);
+	* }
+	* ```
 	*/
 	async updateCartCustomer(pathParams, body) {
 		return this.executeRequest(() => this.client.POST("/pos/carts/{id}/update-customer", {
@@ -1224,14 +1782,85 @@ var PosClient = class extends PosAPIClient {
 	* Create order from cart
 	* @param body - Order creation data
 	* @returns Promise with created order
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.createOrder({
+	*   cart_id: "01H9CART12345ABCDE"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to create order:", error.message);
+	* } else {
+	*   console.log("Order created:", data.order.id);
+	*   console.log("Payment required:", data.payment_required);
+	* }
+	* ```
 	*/
 	async createOrder(body) {
-		return this.executeRequest(() => this.client.POST("/pos/orders", { body }));
+		return this.executeRequest(() => this.storefrontClient.POST("/pos/orders", { body }));
+	}
+	/**
+	* List payment options
+	* @returns Promise with list of payment options
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.listPaymentOptions();
+	*
+	* if (error) {
+	*   console.error("Failed to list payment options:", error.message);
+	* } else {
+	*   console.log("Payment options:", data.payment_options);
+	* }
+	* ```
+	*/
+	async listPaymentOptions() {
+		return this.executeRequest(() => this.client.GET("/pos/payments/payment-options"));
+	}
+	/**
+	* Get payment status
+	* @param pathParams - Order number
+	* @returns Promise with payment status
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.getPaymentStatus({ order_number: "1234567890" });
+	*
+	* if (error) {
+	*   console.error("Failed to get payment status:", error.message);
+	* } else {
+	*   console.log("Payment status:", data.status);
+	*   console.log("Amount paid:", data.amount_paid);
+	*   console.log("Amount unpaid:", data.amount_unpaid);
+	*   console.log("Retry available:", data.is_retry_available);
+	* }
+	* ```
+	*/
+	async getPaymentStatus(pathParams) {
+		return this.executeRequest(() => this.client.GET("/pos/orders/{order_number}/payment-status", { params: { path: pathParams } }));
 	}
 	/**
 	* List all categories
 	* @param query - Optional query parameters for filtering categories
 	* @returns Promise with list of categories
+	* @example
+	* ```typescript
+	* // Basic category listing
+	* const { data, error } = await pos.listCategories();
+	*
+	* if (error) {
+	*   console.error("Failed to list categories:", error.message);
+	* } else {
+	*   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 pos.listCategories({
+	*   page: 1,
+	*   limit: 10
+	* });
+	* ```
 	*/
 	async listCategories(query) {
 		return this.executeRequest(() => this.client.GET("/pos/catalog/categories", { params: { query } }));
@@ -1241,6 +1870,42 @@ var PosClient = class extends PosAPIClient {
 	* @param query - Optional query parameters for filtering products
 	* @param headers - Optional header parameters
 	* @returns Promise with list of products
+	* @example
+	* ```typescript
+	* // Basic product listing
+	* const { data, error } = await pos.listProducts();
+	*
+	* if (error) {
+	*   console.error("Failed to list products:", error.message);
+	* } else {
+	*   console.log("Products found:", data.products?.length || 0);
+	*   console.log("Pagination:", data.pagination);
+	*   data.products?.forEach(product => {
+	*     console.log(`Product: ${product.name} - $${product.price}`);
+	*   });
+	* }
+	*
+	* // With filtering and pagination
+	* const { data: filteredData, error: filteredError } = await pos.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 pos.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
+	*   }
+	* );
+	* ```
 	*/
 	async listProducts(query, headers) {
 		const mergedHeaders = this.mergeHeaders(headers);
@@ -1254,6 +1919,43 @@ var PosClient = class extends PosAPIClient {
 	* @param query - Query parameters with product IDs for cross-sell recommendations
 	* @param headers - Optional header parameters
 	* @returns Promise with cross-sell products
+	* @example
+	* ```typescript
+	* // Basic usage - get cross-sell products for cart items
+	* const { data, error } = await pos.listCrosssellProducts({
+	*   product_ids: ["prod_01H9XYZ12345ABCDE", "prod_01H9ABC67890FGHIJ"]
+	* });
+	*
+	* // Advanced usage with pagination and custom sorting
+	* const { data, error } = await pos.listCrosssellProducts({
+	*   product_ids: ["prod_01H9XYZ12345ABCDE"],
+	*   page: 1,
+	*   limit: 10,
+	*   sort_by: '{"price":"asc"}'
+	* });
+	*
+	* // Override customer group ID for this specific request
+	* const { data, error } = await pos.listCrosssellProducts(
+	*   {
+	*     product_ids: ["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.products.length);
+	*   console.log("Pagination:", data.pagination);
+	*   data.products.forEach(product => {
+	*     console.log(`Product: ${product.name} - ${product.price}`);
+	*   });
+	* }
+	* ```
 	*/
 	async listCrosssellProducts(query, headers) {
 		const mergedHeaders = this.mergeHeaders(headers);
@@ -1267,6 +1969,41 @@ var PosClient = class extends PosAPIClient {
 	* @param body - Search criteria and parameters
 	* @param headers - Optional header parameters
 	* @returns Promise with search results
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.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.message);
+	* } else {
+	*   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 pos.searchProducts(
+	*   {
+	*     query: "laptop",
+	*     filters: { category: ["computers"] }
+	*   },
+	*   {
+	*     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
+	*   }
+	* );
+	* ```
 	*/
 	async searchProducts(body, headers) {
 		const mergedHeaders = this.mergeHeaders(headers);
@@ -1280,6 +2017,43 @@ var PosClient = class extends PosAPIClient {
 	* @param query - Query parameters with product ID for similarity recommendations
 	* @param headers - Optional header parameters
 	* @returns Promise with similar products
+	* @example
+	* ```typescript
+	* // Basic usage - get similar products for a specific product
+	* const { data, error } = await pos.listSimilarProducts({
+	*   product_id: "prod_01H9XYZ12345ABCDE"
+	* });
+	*
+	* // Advanced usage with pagination and custom sorting
+	* const { data, error } = await pos.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 pos.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.products.length);
+	*   console.log("Pagination:", data.pagination);
+	*   data.products.forEach(product => {
+	*     console.log(`Similar: ${product.name} - ${product.price}`);
+	*   });
+	* }
+	* ```
 	*/
 	async listSimilarProducts(query, headers) {
 		const mergedHeaders = this.mergeHeaders(headers);
@@ -1293,6 +2067,43 @@ var PosClient = class extends PosAPIClient {
 	* @param query - Query parameters with product IDs for up-sell recommendations
 	* @param headers - Optional header parameters
 	* @returns Promise with up-sell products
+	* @example
+	* ```typescript
+	* // Basic usage - get up-sell products for cart items
+	* const { data, error } = await pos.listUpsellProducts({
+	*   product_ids: ["prod_01H9XYZ12345ABCDE"]
+	* });
+	*
+	* // Advanced usage with pagination and custom sorting
+	* const { data, error } = await pos.listUpsellProducts({
+	*   product_ids: ["prod_01H9XYZ12345ABCDE"],
+	*   page: 1,
+	*   limit: 15,
+	*   sort_by: '{"relevance":"desc"}'
+	* });
+	*
+	* // Override customer group ID for this specific request
+	* const { data, error } = await pos.listUpsellProducts(
+	*   {
+	*     product_ids: ["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.products.length);
+	*   console.log("Pagination:", data.pagination);
+	*   data.products.forEach(product => {
+	*     console.log(`Up-sell: ${product.name} - ${product.price}`);
+	*   });
+	* }
+	* ```
 	*/
 	async listUpsellProducts(query, headers) {
 		const mergedHeaders = this.mergeHeaders(headers);
@@ -1306,6 +2117,34 @@ var PosClient = class extends PosAPIClient {
 	* @param pathParams - Product ID or slug
 	* @param headers - Optional header parameters
 	* @returns Promise with product details
+	* @example
+	* ```typescript
+	* // Get product by ID
+	* const { data, error } = await pos.getProductDetail(
+	*   { product_id_or_slug: "prod_123" }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to get product details:", error.message);
+	* } else {
+	*   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 pos.getProductDetail({
+	*   product_id_or_slug: "detox-candy"
+	* });
+	*
+	* // Override customer group ID for this specific request
+	* const { data: overrideData, error: overrideError } = await pos.getProductDetail(
+	*   { product_id_or_slug: "detox-candy" },
+	*   {
+	*     "x-customer-group-id": "premium_customers" // Override default SDK config
+	*   }
+	* );
+	* ```
 	*/
 	async getProductDetail(pathParams, headers) {
 		const mergedHeaders = this.mergeHeaders(headers);
@@ -1319,6 +2158,31 @@ var PosClient = class extends PosAPIClient {
 	* @param pathParams - Product ID
 	* @param query - Optional query parameters for filtering reviews
 	* @returns Promise with product reviews
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.listProductReviews(
+	*   { product_id: "prod_123" }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to list product reviews:", error.message);
+	* } else {
+	*   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 pos.listProductReviews(
+	*   { product_id: "prod_123" },
+	*   {
+	*     page: 1,
+	*     limit: 5
+	*   }
+	* );
+	* ```
 	*/
 	async listProductReviews(pathParams, query) {
 		return this.executeRequest(() => this.client.GET("/pos/catalog/products/{product_id}/reviews", { params: {
@@ -1331,6 +2195,29 @@ var PosClient = class extends PosAPIClient {
 	* @param pathParams - Product ID
 	* @param headers - Optional header parameters
 	* @returns Promise with product variants
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.listProductVariants(
+	*   { product_id: "prod_123" }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to list product variants:", error.message);
+	* } else {
+	*   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 pos.listProductVariants(
+	*   { product_id: "prod_123" },
+	*   {
+	*     "x-customer-group-id": "wholesale_customers" // Override default SDK config
+	*   }
+	* );
+	* ```
 	*/
 	async listProductVariants(pathParams, headers) {
 		const mergedHeaders = this.mergeHeaders(headers);
@@ -1344,6 +2231,35 @@ var PosClient = class extends PosAPIClient {
 	* @param pathParams - Product ID and variant ID
 	* @param headers - Optional header parameters
 	* @returns Promise with variant details
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.getVariantDetail(
+	*   {
+	*     product_id: "prod_123",
+	*     variant_id: "var_456"
+	*   }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to get variant details:", error.message);
+	* } else {
+	*   console.log("Variant:", data.variant.name);
+	*   console.log("SKU:", data.variant.sku);
+	*   console.log("Price:", data.variant.price);
+	*   console.log("Stock:", data.variant.stock);
+	* }
+	*
+	* // Override customer group ID for this specific request
+	* const { data: overrideData, error: overrideError } = await pos.getVariantDetail(
+	*   {
+	*     product_id: "prod_123",
+	*     variant_id: "var_456"
+	*   },
+	*   {
+	*     "x-customer-group-id": "wholesale_customers" // Override default SDK config
+	*   }
+	* );
+	* ```
 	*/
 	async getVariantDetail(pathParams, headers) {
 		const mergedHeaders = this.mergeHeaders(headers);
@@ -1357,6 +2273,38 @@ var PosClient = class extends PosAPIClient {
 	* @param query - Optional query parameters for filtering SKUs
 	* @param headers - Optional header parameters
 	* @returns Promise with list of SKUs
+	* @example
+	* ```typescript
+	* // Basic SKU listing
+	* const { data, error } = await pos.listSkus();
+	*
+	* if (error) {
+	*   console.error("Failed to list SKUs:", error.message);
+	* } else {
+	*   console.log("SKUs found:", data.skus?.length || 0);
+	*   console.log("Pagination:", data.pagination);
+	*   data.skus?.forEach(sku => {
+	*     console.log(`SKU: ${sku.sku} - Price: ${sku.price}`);
+	*   });
+	* }
+	*
+	* // With pagination
+	* const { data: skuData, error: skuError } = await pos.listSkus({
+	*   page: 1,
+	*   limit: 50
+	* });
+	*
+	* // Override customer group ID for this specific request
+	* const { data: overrideData, error: overrideError } = await pos.listSkus(
+	*   {
+	*     page: 1,
+	*     limit: 50
+	*   },
+	*   {
+	*     "x-customer-group-id": "01H9XYZ12345USERID" // Override default SDK config
+	*   }
+	* );
+	* ```
 	*/
 	async listSkus(query, headers) {
 		const mergedHeaders = this.mergeHeaders(headers);
@@ -1365,6 +2313,551 @@ var PosClient = class extends PosAPIClient {
 			header: mergedHeaders
 		} }));
 	}
+	/**
+	* List all inventories (Admin)
+	* @param query - Optional query parameters for filtering inventories
+	* @returns Promise with list of inventories
+	* @example
+	* ```typescript
+	* // Basic inventory listing
+	* const { data, error } = await pos.listInventories();
+	*
+	* if (error) {
+	*   console.error("Failed to list inventories:", error.message);
+	* } else {
+	*   console.log("Inventories found:", data.content?.inventories?.length || 0);
+	*   data.content?.inventories?.forEach(inventory => {
+	*     console.log(`Product: ${inventory.product_name} - Stock: ${inventory.stock_quantity}`);
+	*   });
+	* }
+	*
+	* // With pagination and filters
+	* const { data: filteredData, error: filteredError } = await pos.listInventories({
+	*   page: 1,
+	*   limit: 20,
+	*   sort_by: JSON.stringify({ "stock_quantity": "desc" }),
+	*   filters: JSON.stringify({ "product_name": "smartphone" })
+	* });
+	* ```
+	*/
+	async listInventories(query) {
+		return this.executeRequest(() => this.client.GET("/pos/catalog/inventories", { params: { query } }));
+	}
+	/**
+	* List all inventory activities (Admin)
+	* @param query - Optional query parameters for filtering inventory activities
+	* @returns Promise with list of inventory activities
+	* @example
+	* ```typescript
+	* // Basic inventory activities listing
+	* const { data, error } = await pos.listInventoryActivities();
+	*
+	* if (error) {
+	*   console.error("Failed to list inventory activities:", error.message);
+	* } else {
+	*   console.log("Activities found:", data.content?.activities?.length || 0);
+	*   data.content?.activities?.forEach(activity => {
+	*     console.log(`Activity: ${activity.activity_type} - Product: ${activity.product_name} - Quantity: ${activity.quantity}`);
+	*   });
+	* }
+	*
+	* // With pagination and filters
+	* const { data: filteredData, error: filteredError } = await pos.listInventoryActivities({
+	*   page: 1,
+	*   limit: 50,
+	*   sort_by: JSON.stringify({ "created_at": "desc" }),
+	*   filters: JSON.stringify({ "activity_type": "add" })
+	* });
+	* ```
+	*/
+	async listInventoryActivities(query) {
+		return this.executeRequest(() => this.client.GET("/pos/catalog/inventories/activites", { params: { query } }));
+	}
+	/**
+	* Get inventory detail (Admin)
+	* @param query - Query parameters with product/variant information
+	* @returns Promise with inventory details
+	* @example
+	* ```typescript
+	* // Get inventory detail for a product
+	* const { data, error } = await pos.getInventoryDetail({
+	*   product_id: "01H9XYZ12345ABCDE"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to get inventory detail:", error.message);
+	* } else {
+	*   const inventory = data.content?.inventory;
+	*   console.log(`Product: ${inventory?.product_name}`);
+	*   console.log(`Stock: ${inventory?.stock_quantity}`);
+	*   console.log(`Warehouse details:`, inventory?.details);
+	* }
+	*
+	* // Get inventory detail for a product variant
+	* const { data: variantData, error: variantError } = await pos.getInventoryDetail({
+	*   product_id: "01H9XYZ12345ABCDE",
+	*   variant_id: "01H9ABC67890FGHIJ"
+	* });
+	*
+	* // Get inventory detail for a specific lot/batch
+	* const { data: batchData, error: batchError } = await pos.getInventoryDetail({
+	*   product_id: "01H9XYZ12345ABCDE",
+	*   lot_batch: "BATCH001"
+	* });
+	* ```
+	*/
+	async getInventoryDetail(query) {
+		return this.executeRequest(() => this.client.GET("/pos/catalog/inventories/detail", { params: { query } }));
+	}
+	/**
+	* List all customers (Admin)
+	* @param query - Optional query parameters for filtering customers
+	* @returns Promise with list of customers
+	* @example
+	* ```typescript
+	* // Basic customer listing
+	* const { data, error } = await pos.getCustomers();
+	*
+	* if (error) {
+	*   console.error("Failed to list customers:", error.message);
+	* } else {
+	*   console.log("Customers found:", data.content?.customers?.length || 0);
+	*   console.log("Pagination:", data.content?.pagination);
+	*   data.content?.customers?.forEach(customer => {
+	*     console.log(`Customer: ${customer.full_name} - Email: ${customer.email}`);
+	*   });
+	* }
+	*
+	* // With search and pagination
+	* const { data: searchData, error: searchError } = await pos.getCustomers({
+	*   page: 1,
+	*   limit: 20,
+	*   search: "john@example.com",
+	*   sort_by: JSON.stringify({ "created_at": "desc" })
+	* });
+	* ```
+	*/
+	async getCustomers(query) {
+		return this.executeRequest(() => this.client.GET("/pos/customers", { params: { query } }));
+	}
+	/**
+	* Get customer details (Admin)
+	* @param pathParams - Customer ID
+	* @returns Promise with customer details
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.getCustomer({
+	*   id: "01H9CUST12345ABCDE"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to get customer:", error.message);
+	* } else {
+	*   const customer = data.content?.customer;
+	*   console.log(`Customer: ${customer?.full_name}`);
+	*   console.log(`Email: ${customer?.email}`);
+	*   console.log(`Phone: ${customer?.phone}`);
+	*   console.log(`Loyalty points: ${customer?.loyalty?.points_balance}`);
+	*   console.log(`Total spent: ${customer?.loyalty?.lifetime_spent}`);
+	* }
+	* ```
+	*/
+	async getCustomer(pathParams) {
+		return this.executeRequest(() => this.client.GET("/pos/customers/{id}", { params: { path: pathParams } }));
+	}
+	/**
+	* List all orders (Admin)
+	* @param query - Optional query parameters for filtering orders
+	* @returns Promise with list of orders
+	* @example
+	* ```typescript
+	* // Basic order listing
+	* const { data, error } = await pos.listOrders();
+	*
+	* 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} - Status: ${order.status} - Total: ${order.grand_total}`);
+	*   });
+	* }
+	*
+	* // With filters and pagination
+	* const { data: filteredData, error: filteredError } = await pos.listOrders({
+	*   page: 1,
+	*   limit: 50,
+	*   search: "ORD-2024",
+	*   filters: JSON.stringify({ "status": "delivered", "payment_status": "success" }),
+	*   sort_by: JSON.stringify({ "order_date": "desc" })
+	* });
+	* ```
+	*/
+	async listOrders(query) {
+		return this.executeRequest(() => this.adminClient.GET("/pos/orders", { params: { query } }));
+	}
+	/**
+	* Get order details (Admin)
+	* @param pathParams - Order number
+	* @returns Promise with order details
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.getOrderDetail({
+	*   order_number: "ORD-2024-001234"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to get order:", error.message);
+	* } else {
+	*   const order = data.content?.order;
+	*   console.log(`Order: ${order?.order_number}`);
+	*   console.log(`Status: ${order?.status}`);
+	*   console.log(`Payment Status: ${order?.payment_status}`);
+	*   console.log(`Total: ${order?.grand_total}`);
+	*   console.log(`Items:`, order?.order_items);
+	*   console.log(`Billing Address:`, order?.billing_address);
+	*   console.log(`Payments:`, order?.payments);
+	* }
+	* ```
+	*/
+	async getOrderDetail(pathParams) {
+		return this.executeRequest(() => this.client.GET("/pos/orders/{order_number}", { params: { path: pathParams } }));
+	}
+	/**
+	* List order activity (Admin)
+	* @param pathParams - Order number
+	* @returns Promise with order activities
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.listOrderActivity({
+	*   order_number: "ORD-2024-001234"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to get order activity:", error.message);
+	* } else {
+	*   console.log("Activities found:", data.content?.activity?.length || 0);
+	*   data.content?.activity?.forEach(activity => {
+	*     console.log(`${activity.created_at}: ${activity.activity_type} - ${activity.comment}`);
+	*     console.log(`By: ${activity.user_name} (${activity.user_type})`);
+	*   });
+	* }
+	* ```
+	*/
+	async listOrderActivity(pathParams) {
+		return this.executeRequest(() => this.client.GET("/pos/orders/{order_number}/activity", { params: { path: pathParams } }));
+	}
+	/**
+	* Get order invoice (Admin)
+	* @param pathParams - Order number
+	* @param query - Optional format parameter
+	* @returns Promise with order invoice
+	* @example
+	* ```typescript
+	* // Get invoice as JSON
+	* const { data, error } = await pos.getOrderInvoice(
+	*   { order_number: "ORD-2024-001234" },
+	*   { format: "json" }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to get order invoice:", error.message);
+	* } else {
+	*   data.content?.invoices?.forEach(invoice => {
+	*     console.log(`Invoice: ${invoice.invoice_number}`);
+	*     console.log(`Date: ${invoice.invoice_date}`);
+	*     console.log(`Total: ${invoice.grand_total}`);
+	*     console.log(`Items:`, invoice.items);
+	*   });
+	* }
+	*
+	* // Get invoice as PDF
+	* const { data: pdfData, error: pdfError } = await pos.getOrderInvoice(
+	*   { order_number: "ORD-2024-001234" },
+	*   { format: "pdf" }
+	* );
+	* ```
+	*/
+	async getOrderInvoice(pathParams, query) {
+		return this.executeRequest(() => this.client.GET("/pos/orders/{order_number}/invoice", { params: {
+			path: pathParams,
+			query
+		} }));
+	}
+	/**
+	* Get order receipt (Admin)
+	* @param pathParams - Order number
+	* @param query - Optional format parameter
+	* @returns Promise with order receipt
+	* @example
+	* ```typescript
+	* // Get receipt as JSON
+	* const { data, error } = await pos.getOrderReceipt(
+	*   { order_number: "ORD-2024-001234" },
+	*   { format: "json" }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to get order receipt:", error.message);
+	* } else {
+	*   const receipt = data.content?.order_receipt;
+	*   console.log(`Order: ${receipt?.order_number}`);
+	*   console.log(`Date: ${receipt?.order_date}`);
+	*   console.log(`Total: ${receipt?.grand_total}`);
+	*   console.log(`Items:`, receipt?.order_items);
+	*   console.log(`Payments:`, receipt?.payments);
+	* }
+	*
+	* // Get receipt as PDF
+	* const { data: pdfData, error: pdfError } = await pos.getOrderReceipt(
+	*   { order_number: "ORD-2024-001234" },
+	*   { format: "pdf" }
+	* );
+	* ```
+	*/
+	async getOrderReceipt(pathParams, query) {
+		return this.executeRequest(() => this.client.GET("/pos/orders/{order_number}/receipt", { params: {
+			path: pathParams,
+			query
+		} }));
+	}
+	/**
+	* Get order shipments (Admin)
+	* @param pathParams - Order number
+	* @returns Promise with order shipments
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.getOrderShipments({
+	*   order_number: "ORD-2024-001234"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to get order shipments:", error.message);
+	* } else {
+	*   const shipment = data.content?.shipment;
+	*   console.log(`Order: ${shipment?.order_number}`);
+	*   console.log(`Order Status: ${shipment?.order_status}`);
+	*   console.log(`Payment Status: ${shipment?.payment_status}`);
+	*   console.log(`Customer: ${shipment?.customer_name}`);
+	*   console.log(`Shipments:`, shipment?.shipments);
+	*   console.log(`Allowed Actions:`, shipment?.allowed_actions);
+	* }
+	* ```
+	*/
+	async getOrderShipments(pathParams) {
+		return this.executeRequest(() => this.client.GET("/pos/orders/{order_number}/shipments", { params: { path: pathParams } }));
+	}
+	/**
+	* List all shipments (Admin)
+	* @param query - Optional query parameters for filtering shipments
+	* @returns Promise with list of shipments
+	* @example
+	* ```typescript
+	* // Basic shipment listing
+	* const { data, error } = await pos.listShipments();
+	*
+	* if (error) {
+	*   console.error("Failed to list shipments:", error.message);
+	* } else {
+	*   console.log("Shipments found:", data.content?.shipments?.length || 0);
+	*   console.log("Pagination:", data.content?.pagination);
+	*   data.content?.shipments?.forEach(shipment => {
+	*     console.log(`Shipment: ${shipment.shipment_number} - Status: ${shipment.status}`);
+	*     console.log(`Order: ${shipment.order_number} - AWB: ${shipment.awb_no}`);
+	*   });
+	* }
+	*
+	* // With filters and search
+	* const { data: filteredData, error: filteredError } = await pos.listShipments({
+	*   page: 1,
+	*   limit: 25,
+	*   search: "SHIP-2024",
+	*   filters: JSON.stringify({ "status": "shipped" }),
+	*   sort_by: JSON.stringify({ "shipped_date": "desc" })
+	* });
+	* ```
+	*/
+	async listShipments(query) {
+		return this.executeRequest(() => this.client.GET("/pos/shipping/shipments", { params: { query } }));
+	}
+	/**
+	* Check inventory for order (Admin)
+	* @param pathParams - Order number
+	* @returns Promise with inventory check results
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.checkInventory({
+	*   order_number: "ORD-2024-001234"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to check inventory:", error.message);
+	* } else {
+	*   const inventory = data.content;
+	*   console.log(`Inventory Status: ${inventory?.inventory_status}`);
+	*   console.log(`Shipment Items:`, inventory?.shipment_items);
+	*   console.log(`Recommended Warehouses:`, inventory?.recommended_warehouses);
+	*   console.log(`Inventory Detail:`, inventory?.inventory_detail);
+	*   console.log(`Allowed Actions:`, inventory?.allowed_action);
+	* }
+	* ```
+	*/
+	async checkInventory(pathParams) {
+		return this.executeRequest(() => this.client.GET("/pos/shipping/shipments/{order_number}/check-inventory", { params: { path: pathParams } }));
+	}
+	/**
+	* Refund shortfall for order (Admin)
+	* @param pathParams - Order number
+	* @param body - Refund details
+	* @returns Promise with refund confirmation
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.refundShortfall(
+	*   { order_number: "ORD-2024-001234" },
+	*   {
+	*     items: [
+	*       {
+	*         sku: "SKU-123",
+	*         quantity: 2,
+	*         free_quantity: 0
+	*       }
+	*     ],
+	*     payment_method: "original-payment-mode"
+	*   }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to process refund:", error.message);
+	* } else {
+	*   console.log("Refund processed:", data.message);
+	*   console.log("Success:", data.success);
+	* }
+	*
+	* // Refund to bank transfer
+	* const { data: bankData, error: bankError } = await pos.refundShortfall(
+	*   { order_number: "ORD-2024-001234" },
+	*   {
+	*     items: [{ sku: "SKU-123", quantity: 1 }],
+	*     payment_method: "bank-transfer",
+	*     bank_account_id: "BANK_ACC_123"
+	*   }
+	* );
+	* ```
+	*/
+	async refundShortfall(pathParams, body) {
+		return this.executeRequest(() => this.client.POST("/pos/shipping/shipments/{order_number}/refund-shortfall", {
+			params: { path: pathParams },
+			body
+		}));
+	}
+	/**
+	* Get shipment details (Admin)
+	* @param pathParams - Shipment reference number
+	* @returns Promise with shipment details
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.getShipment({
+	*   reference_number: "SHIP-2024-001234"
+	* });
+	*
+	* if (error) {
+	*   console.error("Failed to get shipment:", error.message);
+	* } else {
+	*   const shipment = data.content?.shipment;
+	*   console.log(`Order: ${shipment?.order_number}`);
+	*   console.log(`Shipments:`, shipment?.shipments);
+	*   shipment?.shipments?.forEach(s => {
+	*     console.log(`  Shipment: ${s.shipment_number} - Status: ${s.status}`);
+	*     console.log(`  AWB: ${s.awb_no} - Courier: ${s.courier_company_name}`);
+	*     console.log(`  Items:`, s.shipment_items);
+	*   });
+	* }
+	* ```
+	*/
+	async getShipment(pathParams) {
+		return this.executeRequest(() => this.client.GET("/pos/shipping/shipments/{reference_number}", { params: { path: pathParams } }));
+	}
+	/**
+	* Get shipment invoice (Admin)
+	* @param pathParams - Shipment reference number
+	* @param query - Optional format parameter
+	* @returns Promise with shipment invoice
+	* @example
+	* ```typescript
+	* // Get shipment invoice as JSON
+	* const { data, error } = await pos.getShipmentInvoice(
+	*   { reference_number: "SHIP-2024-001234" },
+	*   { format: "json" }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to get shipment invoice:", error.message);
+	* } else {
+	*   const invoice = data.content?.invoice;
+	*   console.log(`Invoice: ${invoice?.invoice_number}`);
+	*   console.log(`Date: ${invoice?.invoice_date}`);
+	*   console.log(`Total: ${invoice?.grand_total}`);
+	*   console.log(`Items:`, invoice?.items);
+	* }
+	*
+	* // Get shipment invoice as PDF
+	* const { data: pdfData, error: pdfError } = await pos.getShipmentInvoice(
+	*   { reference_number: "SHIP-2024-001234" },
+	*   { format: "pdf" }
+	* );
+	* ```
+	*/
+	async getShipmentInvoice(pathParams, query) {
+		return this.executeRequest(() => this.client.GET("/pos/shipping/shipments/{reference_number}/invoice", { params: {
+			path: pathParams,
+			query
+		} }));
+	}
+	/**
+	* Update shipment details (Admin)
+	* @param pathParams - Shipment reference number
+	* @param body - Shipment update data
+	* @returns Promise with updated shipment
+	* @example
+	* ```typescript
+	* const { data, error } = await pos.updateShipment(
+	*   { reference_number: "SHIP-2024-001234" },
+	*   {
+	*     status: "shipped",
+	*     awb_no: "AWB123456789",
+	*     courier_company_name: "BlueDart",
+	*     shipping_label_url: "https://example.com/label.pdf",
+	*     tracking_url: "https://tracking.example.com/AWB123456789",
+	*     eta_delivery: "2024-01-15T10:00:00Z",
+	*     shipped_date: "2024-01-10T14:30:00Z"
+	*   }
+	* );
+	*
+	* if (error) {
+	*   console.error("Failed to update shipment:", error.message);
+	* } else {
+	*   console.log("Shipment updated successfully:", data.message);
+	*   const shipment = data.content?.shipment;
+	*   console.log(`Updated shipment status:`, shipment?.shipments?.[0]?.status);
+	* }
+	*
+	* // Update delivery status
+	* const { data: deliveryData, error: deliveryError } = await pos.updateShipment(
+	*   { reference_number: "SHIP-2024-001234" },
+	*   {
+	*     status: "delivered",
+	*     delivered_date: "2024-01-15T16:45:00Z"
+	*   }
+	* );
+	* ```
+	*/
+	async updateShipment(pathParams, body) {
+		return this.executeRequest(() => this.client.PUT("/pos/shipping/shipments/{reference_number}/manual-update", {
+			params: { path: pathParams },
+			body
+		}));
+	}
 };
 
 //#endregion