@simpleapps-com/augur-api 0.3.2 → 0.4.0

package/dist/cjs/services/commerce/client.js

@@ -4,8 +4,19 @@ exports.CommerceClient = void 0;
 const base_client_1 = require("../../core/base-client");
 const schemas_1 = require("./schemas");
 /**
- * Commerce API Client
- * @description Client for interacting with Commerce microservice API endpoints for e-commerce operations
+ * Commerce Service Client
+ * @description Client for interacting with Commerce API endpoints for e-commerce cart and checkout operations
+ * @fullPath api.commerce
+ * @service commerce
+ * @domain e-commerce
+ * @discoverable true
+ * @searchTerms ["commerce", "e-commerce", "shopping cart", "checkout", "cart management", "online store"]
+ * @relatedEndpoints ["api.commerce.cartHdr.list.get", "api.commerce.cartLine.get", "api.commerce.checkout.create", "api.avalara.rates.create"]
+ * @commonPatterns ["Shopping cart management", "E-commerce checkout", "Cart operations", "Payment processing"]
+ * @workflow ["shopping-cart", "checkout-process", "e-commerce-operations", "payment-processing"]
+ * @functionalArea "e-commerce-and-cart-management"
+ * @businessRules ["Requires valid bearer authentication", "Shopping cart session management", "Checkout processing", "ERP integration"]
+ * @performance "Optimized for e-commerce workflows and cart operations"
  * @example
  * ```typescript
  * import { HTTPClient } from '@augur/api-client/core';
@@ -14,211 +25,283 @@ const schemas_1 = require("./schemas");
  * const http = new HTTPClient('commerce', { siteId: 'your-site-id', bearerToken: 'your-token' });
  * const commerce = new CommerceClient(http);
  *
+ * // Check service health
+ * const health = await commerce.healthCheck.get();
+ * const healthData = await commerce.healthCheck.getData();
+ *
  * // Create or lookup cart
- * const cart = await commerce.cartHeaders.lookup({ userId: 12345, customerId: 456, contactId: 123 });
+ * const cart = await commerce.cartHdr.lookup.get({ userId: 12345, customerId: 456, contactId: 123 });
  *
  * // Add items to cart
- * await commerce.cartLines.add(cart.cartHdrUid, [{ invMastUid: 12345, quantity: 2, unitOfMeasure: 'EA' }]);
+ * await commerce.cartLine.add.create(cart.cartHdrUid, [{ invMastUid: 12345, quantity: 2, unitOfMeasure: 'EA' }]);
  *
  * // Create checkout
  * const checkout = await commerce.checkout.create({ customer: {...}, payment: {...}, lineItems: [...] });
  * ```
  */
 class CommerceClient extends base_client_1.BaseServiceClient {
-    /**
-     * Create a new CommerceClient instance
-     * @param http Configured HTTPClient instance
-     * @param baseUrl Base URL for the Commerce API (default: https://commerce.augur-api.com)
-     */
-    constructor(http, baseUrl = 'https://commerce.augur-api.com') {
-        super('commerce', http, baseUrl);
+    constructor(http, baseUrl) {
+        super('commerce', http, baseUrl || 'https://commerce.augur-api.com');
         /**
-         * Cart Header endpoints
-         * @description Methods for shopping cart session management with user tracking and cart tokens
+         * Health Check Operations
+         * @description System health monitoring and availability verification for Commerce service
          */
-        this.cartHeaders = {
-            /**
-             * Retrieve a list of cart headers for a specific user
-             *
-             * @fullPath api.commerce.cartHeaders.list
-             * @service commerce
-             * @domain cart-management
-             * @dataMethod listData
-             * @discoverable true
-             * @searchTerms ["cart", "list", "shopping cart", "user carts", "cart headers", "session", "baskets"]
-             * @relatedEndpoints ["api.commerce.cartLines.get", "api.commerce.cartHeaders.lookup", "api.customers.customer.list", "api.joomla.users.list"]
-             * @commonPatterns ["Get all user carts", "List shopping carts", "Find user sessions", "Shopping cart history"]
-             * @workflow ["cart-management", "session-tracking", "user-cart-retrieval"]
-             * @prerequisites ["Valid authentication token", "Valid user ID", "Cart management permissions"]
-             * @nextSteps ["api.commerce.cartLines.get for cart contents", "api.commerce.cartHeaders.lookup for specific cart"]
-             * @businessRules ["Returns only carts accessible to current user", "Respects user permissions", "Includes abandoned carts"]
-             * @functionalArea "cart-and-session-management"
-             * @caching "Cache for 2 minutes, invalidate on cart changes"
-             * @performance "Lightweight operation, pagination not required for typical usage"
-             *
-             * @description Returns all cart headers associated with a user ID for session management and cart recovery
-             * @param params User ID for filtering cart headers
-             * @returns Promise<BaseResponse<CartHdr[]>> Complete response with cart headers array and metadata
-             * @throws ValidationError When parameters are invalid or response is malformed
-             *
-             * @example
-             * ```typescript
-             * // Get all carts for a user
-             * const response = await client.cartHeaders.list({ userId: 12345 });
-             * console.log(response.data); // CartHdr[]
-             *
-             * // Get just the data array
-             * const carts = await client.cartHeaders.listData({ userId: 12345 });
-             * carts.forEach(cart => console.log(cart.cartHdrUid, cart.cartToken));
-             * ```
-             */
-            list: this.createListMethod('/cart-hdr/list', schemas_1.CartHdrListParamsSchema, schemas_1.CartHdrListResponseSchema),
+        this.healthCheck = {
             /**
-             * Lookup an existing cart or create a new one
+             * Check service health and availability
              *
-             * @fullPath api.commerce.cartHeaders.lookup
+             * @fullPath api.commerce.healthCheck.get
              * @service commerce
-             * @domain cart-management
-             * @dataMethod lookupData
+             * @domain system-health
+             * @dataMethod healthCheck.getData - returns only the health status data without metadata
              * @discoverable true
-             * @searchTerms ["cart lookup", "find cart", "get cart", "cart token", "shopping cart", "user cart", "session cart"]
-             * @relatedEndpoints ["api.commerce.cartHeaders.list", "api.commerce.cartLines.get", "api.customers.customer.get", "api.joomla.users.get"]
-             * @commonPatterns ["Find user's active cart", "Get or create cart", "Resume shopping session", "Cart token validation"]
-             * @workflow ["cart-retrieval", "session-management", "cart-creation"]
-             * @prerequisites ["Valid authentication token", "Valid user, customer, and contact IDs"]
-             * @nextSteps ["api.commerce.cartLines.get for cart contents", "api.commerce.cartLines.add to add items"]
-             * @businessRules ["Creates new cart if none exists", "Returns existing cart if found", "Validates user permissions"]
-             * @functionalArea "cart-and-session-management"
-             * @caching "Cache for 5 minutes, invalidate on cart modifications"
-             * @performance "Fast lookup operation, includes cart creation logic"
+             * @searchTerms ["health", "status", "availability", "ping", "check", "commerce service", "monitoring"]
+             * @relatedEndpoints ["api.commerce.cartHdr.list.get", "api.commerce.checkout.create", "api.avalara.healthCheck.get", "api.items.healthCheck.get"]
+             * @commonPatterns ["Health check", "Service status", "Commerce service availability", "System monitoring"]
+             * @workflow ["system-monitoring", "health-checks", "service-discovery", "commerce-service-verification"]
+             * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header"]
+             * @nextSteps ["Use commerce endpoints if healthy", "Verify commerce service connectivity", "Monitor service metrics"]
+             * @businessRules ["Returns service status and site configuration", "Requires standard authentication", "Standard health check format"]
+             * @functionalArea "system-monitoring"
+             * @caching "No caching - real-time status required"
+             * @performance "Fast response, minimal processing, use for commerce service monitoring"
              *
-             * @description Looks up an existing cart or creates a new one for the specified user, customer, and contact
-             * @param params User, customer, and contact identifiers with optional cart token
-             * @returns Promise<BaseResponse<CartHdr>> Complete response with cart header details and metadata
-             * @throws ValidationError When parameters are invalid or response is malformed
+             * @returns Promise<HealthCheckResponse> Service health status
              *
              * @example
              * ```typescript
-             * // Lookup existing cart
-             * const response = await client.cartHeaders.lookup({
-             *   userId: 12345,
-             *   customerId: 456,
-             *   contactId: 123,
-             *   cartToken: 'abc123'
-             * });
-             * console.log(response.data.cartHdrUid);
+             * // Check if commerce service is healthy
+             * const response = await client.healthCheck.get();
+             * console.log(response.data.siteId); // Site identifier
+             * console.log(response.status); // HTTP status code
              *
-             * // Create new cart (data method)
-             * const cart = await client.cartHeaders.lookupData({
-             *   userId: 12345,
-             *   customerId: 456,
-             *   contactId: 123
-             * });
+             * // Get just the health status
+             * const status = await client.healthCheck.getData();
+             * console.log(status); // Direct object access
              * ```
              */
-            lookup: async (params) => {
+            get: async () => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/cart-hdr/lookup',
-                    paramsSchema: schemas_1.CartHdrLookupParamsSchema,
-                    responseSchema: schemas_1.CartHdrLookupResponseSchema,
-                }, params);
+                    path: '/health-check',
+                    responseSchema: schemas_1.HealthCheckResponseSchema,
+                }, undefined);
             },
             /**
-             * Get product recommendations based on cart contents
-             *
-             * @fullPath api.commerce.cartHeaders.getAlsoBought
-             * @service commerce
-             * @domain recommendation-engine
-             * @dataMethod getAlsoBoughtData
-             * @discoverable true
-             * @searchTerms ["recommendations", "also bought", "cross sell", "upsell", "related products", "suggestions", "shopping recommendations"]
-             * @relatedEndpoints ["api.commerce.cartLines.get", "api.items.products.list", "api.legacy.alsoBought.list"]
-             * @commonPatterns ["Get product recommendations", "Cross-sell products", "Increase cart value", "Related item suggestions"]
-             * @workflow ["recommendation-display", "cross-selling", "cart-enhancement"]
-             * @prerequisites ["Valid cart header UID", "Cart with existing items for best recommendations"]
-             * @nextSteps ["api.commerce.cartLines.add to add recommended items", "api.items.products.get for product details"]
-             * @businessRules ["Based on purchase history patterns", "Respects inventory availability", "Paginated results for performance"]
-             * @functionalArea "recommendation-and-cross-sell"
-             * @caching "Cache for 30 minutes, static recommendation data"
-             * @performance "Supports pagination with limit/offset, optimized for recommendation engine"
-             *
-             * @description Retrieves also-bought product recommendations based on items currently in the cart
-             * @param cartHdrUid Cart header unique identifier
-             * @param params Optional pagination parameters (limit, offset)
-             * @returns Promise<BaseResponse<AlsoBoughtItem[]>> Complete response with recommended products and pagination metadata
-             * @throws ValidationError When parameters are invalid or response is malformed
-             *
-             * @example
-             * ```typescript
-             * // Get recommendations with pagination
-             * const response = await client.cartHeaders.getAlsoBought(789, { limit: 5, offset: 0 });
-             * console.log(`Found ${response.total} recommendations, showing ${response.count}`);
-             * response.data.forEach(item => console.log(item.itemId, item.description, item.price));
-             *
-             * // Get just the data array
-             * const recommendations = await client.cartHeaders.getAlsoBoughtData(789, { limit: 10 });
-             * ```
+             * Get health check status data only
+             * @returns Promise<unknown> Health status data
              */
-            getAlsoBought: async (cartHdrUid, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/cart-hdr/{cartHdrUid}/also-bought',
-                    paramsSchema: schemas_1.AlsoBoughtParamsSchema,
-                    responseSchema: schemas_1.AlsoBoughtResponseSchema,
-                }, params, { cartHdrUid: String(cartHdrUid) });
+            getData: async () => {
+                const response = await this.healthCheck.get();
+                return response.data;
             },
+        };
+        /**
+         * Cart Header Operations
+         * @description Cart header management and session tracking functionality
+         */
+        this.cartHdr = {
             /**
-             * Get list of cart headers (data only)
-             * @description Data-only version of list method - returns just the cart headers array
-             * @param params User ID for filtering cart headers
-             * @returns Array of cart headers for the user
+             * List Operations
+             * @description Cart header list functionality for user cart retrieval
              */
-            listData: async (params) => {
-                const response = await this.cartHeaders.list(params);
-                return response.data;
+            list: {
+                /**
+                 * Retrieve a list of cart headers for a specific user
+                 *
+                 * @fullPath api.commerce.cartHdr.list.get
+                 * @service commerce
+                 * @domain cart-management
+                 * @dataMethod cartHdr.list.getData - returns only the cart headers data without metadata
+                 * @discoverable true
+                 * @searchTerms ["cart", "list", "shopping cart", "user carts", "cart headers", "session", "baskets"]
+                 * @relatedEndpoints ["api.commerce.cartLine.get", "api.commerce.cartHdr.lookup.get", "api.customers.customer.list", "api.joomla.users.list"]
+                 * @commonPatterns ["Get all user carts", "List shopping carts", "Find user sessions", "Shopping cart history"]
+                 * @workflow ["cart-management", "session-tracking", "user-cart-retrieval"]
+                 * @prerequisites ["Valid authentication token", "Valid user ID", "Cart management permissions"]
+                 * @nextSteps ["api.commerce.cartLine.get for cart contents", "api.commerce.cartHdr.lookup.get for specific cart"]
+                 * @businessRules ["Returns only carts accessible to current user", "Respects user permissions", "Includes abandoned carts"]
+                 * @functionalArea "cart-and-session-management"
+                 * @caching "Cache for 2 minutes, invalidate on cart changes"
+                 * @performance "Lightweight operation, pagination not required for typical usage"
+                 *
+                 * @description Returns all cart headers associated with a user ID for session management and cart recovery
+                 * @param params User ID for filtering cart headers
+                 * @returns Promise<CartHdrListResponse> Complete response with cart headers array and metadata
+                 * @throws ValidationError When parameters are invalid or response is malformed
+                 *
+                 * @example
+                 * ```typescript
+                 * // Get all carts for a user
+                 * const response = await client.cartHdr.list.get({ userId: 12345 });
+                 * console.log(response.data); // CartHdr[]
+                 *
+                 * // Get just the data array
+                 * const carts = await client.cartHdr.list.getData({ userId: 12345 });
+                 * carts.forEach(cart => console.log(cart.cartHdrUid, cart.cartToken));
+                 * ```
+                 */
+                get: async (params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/cart-hdr/list',
+                        responseSchema: schemas_1.CartHdrListResponseSchema,
+                    }, params);
+                },
+                /**
+                 * Get list of cart headers data only
+                 * @param params User ID for filtering cart headers
+                 * @returns Promise<unknown[]> Array of cart headers for the user
+                 */
+                getData: async (params) => {
+                    const response = await this.cartHdr.list.get(params);
+                    return response.data;
+                },
             },
             /**
-             * Lookup cart header (data only)
-             * @description Data-only version of lookup method - returns just the cart header object
-             * @param params User, customer, and contact identifiers with optional cart token
-             * @returns Cart header details
+             * Lookup Operations
+             * @description Cart header lookup functionality for cart retrieval or creation
              */
-            lookupData: async (params) => {
-                const response = await this.cartHeaders.lookup(params);
-                return response.data;
+            lookup: {
+                /**
+                 * Lookup an existing cart or create a new one
+                 *
+                 * @fullPath api.commerce.cartHdr.lookup.get
+                 * @service commerce
+                 * @domain cart-management
+                 * @dataMethod cartHdr.lookup.getData - returns only the cart header data without metadata
+                 * @discoverable true
+                 * @searchTerms ["cart lookup", "find cart", "get cart", "cart token", "shopping cart", "user cart", "session cart"]
+                 * @relatedEndpoints ["api.commerce.cartHdr.list.get", "api.commerce.cartLine.get", "api.customers.customer.get", "api.joomla.users.get"]
+                 * @commonPatterns ["Find user's active cart", "Get or create cart", "Resume shopping session", "Cart token validation"]
+                 * @workflow ["cart-retrieval", "session-management", "cart-creation"]
+                 * @prerequisites ["Valid authentication token", "Valid user, customer, and contact IDs"]
+                 * @nextSteps ["api.commerce.cartLine.get for cart contents", "api.commerce.cartLine.add.create to add items"]
+                 * @businessRules ["Creates new cart if none exists", "Returns existing cart if found", "Validates user permissions"]
+                 * @functionalArea "cart-and-session-management"
+                 * @caching "Cache for 5 minutes, invalidate on cart modifications"
+                 * @performance "Fast lookup operation, includes cart creation logic"
+                 *
+                 * @description Looks up an existing cart or creates a new one for the specified user, customer, and contact
+                 * @param params User, customer, and contact identifiers with optional cart token
+                 * @returns Promise<CartHdrLookupResponse> Complete response with cart header details and metadata
+                 * @throws ValidationError When parameters are invalid or response is malformed
+                 *
+                 * @example
+                 * ```typescript
+                 * // Lookup existing cart
+                 * const response = await client.cartHdr.lookup.get({
+                 *   userId: 12345,
+                 *   customerId: 456,
+                 *   contactId: 123,
+                 *   cartToken: 'abc123'
+                 * });
+                 * console.log(response.data.cartHdrUid);
+                 *
+                 * // Create new cart (data method)
+                 * const cart = await client.cartHdr.lookup.getData({
+                 *   userId: 12345,
+                 *   customerId: 456,
+                 *   contactId: 123
+                 * });
+                 * ```
+                 */
+                get: async (params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/cart-hdr/lookup',
+                        responseSchema: schemas_1.CartHdrLookupResponseSchema,
+                    }, params);
+                },
+                /**
+                 * Lookup cart header data only
+                 * @param params User, customer, and contact identifiers with optional cart token
+                 * @returns Promise<unknown> Cart header details
+                 */
+                getData: async (params) => {
+                    const response = await this.cartHdr.lookup.get(params);
+                    return response.data;
+                },
             },
             /**
-             * Get also bought recommendations (data only)
-             * @description Data-only version of getAlsoBought method - returns just the recommendations array
-             * @param cartHdrUid Cart header unique identifier
-             * @param params Optional pagination parameters
-             * @returns Array of recommended products
+             * Also Bought Operations
+             * @description Product recommendation functionality based on cart contents
              */
-            getAlsoBoughtData: async (cartHdrUid, params) => {
-                const response = await this.cartHeaders.getAlsoBought(cartHdrUid, params);
-                return response.data;
+            alsoBought: {
+                /**
+                 * Get product recommendations based on cart contents
+                 *
+                 * @fullPath api.commerce.cartHdr.alsoBought.get
+                 * @service commerce
+                 * @domain recommendation-engine
+                 * @dataMethod cartHdr.alsoBought.getData - returns only the recommendations data without metadata
+                 * @discoverable true
+                 * @searchTerms ["recommendations", "also bought", "cross sell", "upsell", "related products", "suggestions", "shopping recommendations"]
+                 * @relatedEndpoints ["api.commerce.cartLine.get", "api.items.products.list", "api.legacy.alsoBought.list"]
+                 * @commonPatterns ["Get product recommendations", "Cross-sell products", "Increase cart value", "Related item suggestions"]
+                 * @workflow ["recommendation-display", "cross-selling", "cart-enhancement"]
+                 * @prerequisites ["Valid cart header UID", "Cart with existing items for best recommendations"]
+                 * @nextSteps ["api.commerce.cartLine.add.create to add recommended items", "api.items.products.get for product details"]
+                 * @businessRules ["Based on purchase history patterns", "Respects inventory availability", "Paginated results for performance"]
+                 * @functionalArea "recommendation-and-cross-sell"
+                 * @caching "Cache for 30 minutes, static recommendation data"
+                 * @performance "Supports pagination with limit/offset, optimized for recommendation engine"
+                 *
+                 * @description Retrieves also-bought product recommendations based on items currently in the cart
+                 * @param cartHdrUid Cart header unique identifier
+                 * @param params Optional pagination parameters (limit, offset)
+                 * @returns Promise<AlsoBoughtResponse> Complete response with recommended products and pagination metadata
+                 * @throws ValidationError When parameters are invalid or response is malformed
+                 *
+                 * @example
+                 * ```typescript
+                 * // Get recommendations with pagination
+                 * const response = await client.cartHdr.alsoBought.get(789, { limit: 5, offset: 0 });
+                 * console.log(`Found ${response.total} recommendations, showing ${response.count}`);
+                 * response.data.forEach(item => console.log(item.itemId, item.description, item.price));
+                 *
+                 * // Get just the data array
+                 * const recommendations = await client.cartHdr.alsoBought.getData(789, { limit: 10 });
+                 * ```
+                 */
+                get: async (cartHdrUid, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/cart-hdr/{cartHdrUid}/also-bought',
+                        responseSchema: schemas_1.AlsoBoughtResponseSchema,
+                    }, params, { cartHdrUid: String(cartHdrUid) });
+                },
+                /**
+                 * Get also bought recommendations data only
+                 * @param cartHdrUid Cart header unique identifier
+                 * @param params Optional pagination parameters
+                 * @returns Promise<unknown[]> Array of recommended products
+                 */
+                getData: async (cartHdrUid, params) => {
+                    const response = await this.cartHdr.alsoBought.get(cartHdrUid, params);
+                    return response.data;
+                },
             },
         };
         /**
-         * Cart Line endpoints
-         * @description Methods for managing individual line items within shopping carts
+         * Cart Line Operations
+         * @description Cart line management for individual items within shopping carts
          */
-        this.cartLines = {
+        this.cartLine = {
             /**
              * Retrieve all line items for a specific cart
              *
-             * @fullPath api.commerce.cartLines.get
+             * @fullPath api.commerce.cartLine.get
              * @service commerce
              * @domain cart-management
-             * @dataMethod getData
+             * @dataMethod cartLine.getData - returns only the cart line data without metadata
              * @discoverable true
              * @searchTerms ["cart lines", "cart items", "line items", "cart contents", "shopping cart items", "cart products"]
-             * @relatedEndpoints ["api.commerce.cartHeaders.lookup", "api.items.products.get", "api.commerce.cartLines.add", "api.commerce.cartLines.update"]
+             * @relatedEndpoints ["api.commerce.cartHdr.lookup.get", "api.items.products.get", "api.commerce.cartLine.add.create", "api.commerce.cartLine.update.create"]
              * @commonPatterns ["View cart contents", "Get cart line items", "Display shopping cart", "Cart item details"]
              * @workflow ["cart-display", "cart-review", "checkout-preparation"]
              * @prerequisites ["Valid cart header UID", "Cart must exist"]
-             * @nextSteps ["api.commerce.cartLines.update to modify items", "api.commerce.checkout.create to proceed to checkout"]
+             * @nextSteps ["api.commerce.cartLine.update.create to modify items", "api.commerce.checkout.create to proceed to checkout"]
              * @businessRules ["Returns all line items in cart", "Includes product details and pricing", "Ordered by line number"]
              * @functionalArea "cart-and-session-management"
              * @caching "Cache for 2 minutes, invalidate on cart modifications"
@@ -226,218 +309,320 @@ class CommerceClient extends base_client_1.BaseServiceClient {
              *
              * @description Returns all line items in a cart with product details, quantities, and pricing
              * @param cartHdrUid Cart header unique identifier
-             * @returns Promise<BaseResponse<CartLine[]>> Complete response with cart line items and metadata
+             * @returns Promise<CartLineListResponse> Complete response with cart line items and metadata
              * @throws ValidationError When response is malformed
              *
              * @example
              * ```typescript
              * // Get cart line items
-             * const response = await client.cartLines.get(789);
+             * const response = await client.cartLine.get(789);
              * response.data.forEach(line => {
              *   console.log(`Line ${line.lineNo}: ${line.quantity} x ${line.itemId} @ $${line.unitPrice}`);
              * });
              *
              * // Get just the data array
-             * const lines = await client.cartLines.getData(789);
+             * const lines = await client.cartLine.getData(789);
              * ```
              */
-            get: this.createGetMethod('/cart-line/{cartHdrUid}', schemas_1.CartLineListResponseSchema),
+            get: async (cartHdrUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/cart-line/{cartHdrUid}',
+                    responseSchema: schemas_1.CartLineListResponseSchema,
+                }, undefined, { cartHdrUid: String(cartHdrUid) });
+            },
             /**
-             * Add one or more items to the cart
+             * Remove all line items from the cart
              *
-             * @fullPath api.commerce.cartLines.add
+             * @fullPath api.commerce.cartLine.delete
              * @service commerce
              * @domain cart-management
-             * @dataMethod addData
+             * @dataMethod cartLine.deleteData - returns only the delete result data without metadata
              * @discoverable true
-             * @searchTerms ["add to cart", "cart add", "add items", "shopping cart add", "add products", "cart line add"]
-             * @relatedEndpoints ["api.commerce.cartLines.get", "api.commerce.cartLines.update", "api.items.products.get", "api.pricing.pricing.calculate"]
-             * @commonPatterns ["Add item to cart", "Add multiple items", "Bulk add to cart", "Shopping cart addition"]
-             * @workflow ["product-to-cart", "shopping-flow", "cart-building"]
-             * @prerequisites ["Valid cart header UID", "Valid product inventory UIDs", "Items must be available"]
-             * @nextSteps ["api.commerce.cartLines.get to view updated cart", "api.commerce.checkout.create to proceed to checkout"]
-             * @businessRules ["Aggregates quantities for duplicate items", "Validates inventory availability", "Applies pricing rules"]
+             * @searchTerms ["clear cart", "delete cart lines", "remove all items", "empty cart", "cart clear"]
+             * @relatedEndpoints ["api.commerce.cartLine.get", "api.commerce.cartLine.lines.delete", "api.commerce.cartHdr.lookup.get"]
+             * @commonPatterns ["Clear cart contents", "Remove all items", "Empty shopping cart", "Reset cart"]
+             * @workflow ["cart-clearing", "cart-reset", "cart-management"]
+             * @prerequisites ["Valid cart header UID", "Cart must exist"]
+             * @nextSteps ["api.commerce.cartLine.add.create to add new items", "api.commerce.cartHdr.lookup.get to verify empty cart"]
+             * @businessRules ["Removes all line items from cart", "Preserves cart header", "Updates cart totals"]
              * @functionalArea "cart-and-session-management"
              * @caching "No caching, immediate cart modification"
-             * @performance "Batch operation for multiple items, validates inventory in bulk"
-             *
-             * @description Adds line items to the shopping cart with automatic quantity aggregation for matching items
-             * @param cartHdrUid Cart header unique identifier
-             * @param items Array of cart line items to add
-             * @returns Promise<BaseResponse<boolean>> Complete response with success status and metadata
-             * @throws ValidationError When request is invalid or response is malformed
-             *
-             * @example
-             * ```typescript
-             * // Add multiple items to cart
-             * const response = await client.cartLines.add(789, [
-             *   {
-             *     invMastUid: 12345,
-             *     quantity: 2.0,
-             *     unitOfMeasure: 'EA',
-             *     lineNote: 'Rush order',
-             *     unitPrice: 29.99
-             *   },
-             *   {
-             *     invMastUid: 67890,
-             *     quantity: 1.0,
-             *     unitOfMeasure: 'LB'
-             *   }
-             * ]);
+             * @performance "Fast bulk delete operation"
              *
-             * // Get just the success boolean
-             * const success = await client.cartLines.addData(789, items);
-             * ```
-             */
-            add: async (cartHdrUid, items) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/cart-line/{cartHdrUid}/add',
-                    paramsSchema: schemas_1.CartLineAddRequestSchema,
-                    responseSchema: schemas_1.CartLineModifyResponseSchema,
-                }, items, { cartHdrUid: String(cartHdrUid) });
-            },
-            /**
-             * Update quantities or details for existing cart line items
-             * @description Updates existing line items in the cart with new quantities, notes, or other modifications
-             * @param cartHdrUid Cart header unique identifier
-             * @param items Array of cart line items to update (must specify lineNo or key for identification)
-             * @returns Boolean indicating successful update
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * const success = await client.cartLines.update(789, [
-             *   {
-             *     lineNo: 1,
-             *     quantity: 5.0,
-             *     lineNote: 'Updated quantity to 5'
-             *   },
-             *   {
-             *     key: 'unique-key-123',
-             *     quantity: 3.0
-             *   }
-             * ]);
-             * ```
-             */
-            update: async (cartHdrUid, items) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/cart-line/{cartHdrUid}/update',
-                    paramsSchema: schemas_1.CartLineUpdateRequestSchema,
-                    responseSchema: schemas_1.CartLineModifyResponseSchema,
-                }, items, { cartHdrUid: String(cartHdrUid) });
-            },
-            /**
-             * Remove all line items from the cart
              * @description Clears all line items from the specified cart, leaving the cart header intact
              * @param cartHdrUid Cart header unique identifier
-             * @returns Boolean indicating successful clearing of cart
+             * @returns Promise<CartLineModifyResponse> Complete response with deletion status and metadata
              * @throws ValidationError When response is malformed
+             *
              * @example
              * ```typescript
-             * const success = await client.cartLines.clear(789);
-             * if (success) {
+             * // Clear all items from cart
+             * const response = await client.cartLine.delete(789);
+             * if (response.data.success) {
              *   console.log('Cart has been cleared of all items');
              * }
+             *
+             * // Get just the result data
+             * const result = await client.cartLine.deleteData(789);
              * ```
              */
-            clear: this.createDeleteMethod('/cart-line/{cartHdrUid}', schemas_1.CartLineModifyResponseSchema),
-            /**
-             * Remove a specific line item from the cart
-             * @description Removes a single line item from the cart by line number
-             * @param cartHdrUid Cart header unique identifier
-             * @param lineNo Line number to delete
-             * @returns Boolean indicating successful deletion
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const success = await client.cartLines.deleteLine(789, 1);
-             * if (success) {
-             *   console.log('Line item 1 has been removed from cart');
-             * }
-             * ```
-             */
-            deleteLine: async (cartHdrUid, lineNo) => {
+            delete: async (cartHdrUid) => {
                 return this.executeRequest({
                     method: 'DELETE',
-                    path: '/cart-line/{cartHdrUid}/lines/{lineNo}',
-                    responseSchema: schemas_1.CartLineDeleteResponseSchema,
-                }, undefined, { cartHdrUid: String(cartHdrUid), lineNo: String(lineNo) });
+                    path: '/cart-line/{cartHdrUid}',
+                    responseSchema: schemas_1.CartLineModifyResponseSchema,
+                }, undefined, { cartHdrUid: String(cartHdrUid) });
             },
-            // Data-only methods for cart lines
             /**
-             * Get cart line items (data only)
-             * @description Returns only the data array from cart line items response
-             * @param cartHdrUid Cart header unique identifier
-             * @returns Array of cart line items (data only)
-             * @throws ValidationError When response is malformed
+             * Add Operations
+             * @description Cart line addition functionality for adding items to cart
              */
-            getData: async (cartHdrUid) => {
-                const response = await this.cartLines.get(cartHdrUid);
-                return response.data;
+            add: {
+                /**
+                 * Add one or more items to the cart
+                 *
+                 * @fullPath api.commerce.cartLine.add.create
+                 * @service commerce
+                 * @domain cart-management
+                 * @dataMethod cartLine.add.getData - returns only the addition result data without metadata
+                 * @discoverable true
+                 * @searchTerms ["add to cart", "cart add", "add items", "shopping cart add", "add products", "cart line add"]
+                 * @relatedEndpoints ["api.commerce.cartLine.get", "api.commerce.cartLine.update.create", "api.items.products.get", "api.pricing.pricing.calculate"]
+                 * @commonPatterns ["Add item to cart", "Add multiple items", "Bulk add to cart", "Shopping cart addition"]
+                 * @workflow ["product-to-cart", "shopping-flow", "cart-building"]
+                 * @prerequisites ["Valid cart header UID", "Valid product inventory UIDs", "Items must be available"]
+                 * @nextSteps ["api.commerce.cartLine.get to view updated cart", "api.commerce.checkout.create to proceed to checkout"]
+                 * @businessRules ["Aggregates quantities for duplicate items", "Validates inventory availability", "Applies pricing rules"]
+                 * @functionalArea "cart-and-session-management"
+                 * @caching "No caching, immediate cart modification"
+                 * @performance "Batch operation for multiple items, validates inventory in bulk"
+                 *
+                 * @description Adds line items to the shopping cart with automatic quantity aggregation for matching items
+                 * @param cartHdrUid Cart header unique identifier
+                 * @param items Array of cart line items to add
+                 * @returns Promise<CartLineModifyResponse> Complete response with addition status and metadata
+                 * @throws ValidationError When request is invalid or response is malformed
+                 *
+                 * @example
+                 * ```typescript
+                 * // Add multiple items to cart
+                 * const response = await client.cartLine.add.create(789, [
+                 *   {
+                 *     invMastUid: 12345,
+                 *     quantity: 2.0,
+                 *     unitOfMeasure: 'EA',
+                 *     lineNote: 'Rush order',
+                 *     unitPrice: 29.99
+                 *   },
+                 *   {
+                 *     invMastUid: 67890,
+                 *     quantity: 1.0,
+                 *     unitOfMeasure: 'LB'
+                 *   }
+                 * ]);
+                 *
+                 * // Get just the success result
+                 * const result = await client.cartLine.add.getData(789, items);
+                 * ```
+                 */
+                create: async (cartHdrUid, items) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/cart-line/{cartHdrUid}/add',
+                        responseSchema: schemas_1.CartLineModifyResponseSchema,
+                    }, items, { cartHdrUid: String(cartHdrUid) });
+                },
+                /**
+                 * Add items to cart data only
+                 * @param cartHdrUid Cart header unique identifier
+                 * @param items Array of cart line items to add
+                 * @returns Promise<unknown> Addition result data only
+                 */
+                getData: async (cartHdrUid, items) => {
+                    const response = await this.cartLine.add.create(cartHdrUid, items);
+                    return response.data;
+                },
             },
             /**
-             * Add items to cart (data only)
-             * @description Returns only the data from cart line addition response
-             * @param cartHdrUid Cart header unique identifier
-             * @param items Array of cart line items to add
-             * @returns Addition result (data only)
-             * @throws ValidationError When request is invalid or response is malformed
+             * Lines Operations
+             * @description Individual cart line management functionality
              */
-            addData: async (cartHdrUid, items) => {
-                const response = await this.cartLines.add(cartHdrUid, items);
-                return response.data;
+            lines: {
+                /**
+                 * Remove a specific line item from the cart
+                 *
+                 * @fullPath api.commerce.cartLine.lines.delete
+                 * @service commerce
+                 * @domain cart-management
+                 * @dataMethod cartLine.lines.deleteData - returns only the deletion result data without metadata
+                 * @discoverable true
+                 * @searchTerms ["remove line item", "delete cart line", "remove item", "cart item delete", "line delete"]
+                 * @relatedEndpoints ["api.commerce.cartLine.get", "api.commerce.cartLine.delete", "api.commerce.cartLine.update.create"]
+                 * @commonPatterns ["Remove specific item", "Delete cart line", "Remove line by number", "Item removal"]
+                 * @workflow ["cart-modification", "item-removal", "cart-management"]
+                 * @prerequisites ["Valid cart header UID", "Valid line number", "Line must exist"]
+                 * @nextSteps ["api.commerce.cartLine.get to view updated cart", "api.commerce.cartLine.add.create to add replacement items"]
+                 * @businessRules ["Removes single line item", "Updates cart totals", "Preserves other line items"]
+                 * @functionalArea "cart-and-session-management"
+                 * @caching "No caching, immediate cart modification"
+                 * @performance "Fast single line deletion"
+                 *
+                 * @description Removes a single line item from the cart by line number
+                 * @param cartHdrUid Cart header unique identifier
+                 * @param lineNo Line number to delete
+                 * @returns Promise<CartLineDeleteResponse> Complete response with deletion status and metadata
+                 * @throws ValidationError When response is malformed
+                 *
+                 * @example
+                 * ```typescript
+                 * // Remove specific line item
+                 * const response = await client.cartLine.lines.delete(789, 1);
+                 * if (response.data.success) {
+                 *   console.log('Line item 1 has been removed from cart');
+                 * }
+                 *
+                 * // Get just the result data
+                 * const result = await client.cartLine.lines.deleteData(789, 1);
+                 * ```
+                 */
+                delete: async (cartHdrUid, lineNo) => {
+                    return this.executeRequest({
+                        method: 'DELETE',
+                        path: '/cart-line/{cartHdrUid}/lines/{lineNo}',
+                        responseSchema: schemas_1.CartLineDeleteResponseSchema,
+                    }, undefined, { cartHdrUid: String(cartHdrUid), lineNo: String(lineNo) });
+                },
+                /**
+                 * Delete specific cart line item data only
+                 * @param cartHdrUid Cart header unique identifier
+                 * @param lineNo Line number to delete
+                 * @returns Promise<unknown> Deletion result data only
+                 */
+                deleteData: async (cartHdrUid, lineNo) => {
+                    const response = await this.cartLine.lines.delete(cartHdrUid, lineNo);
+                    return response.data;
+                },
             },
             /**
-             * Update cart line items (data only)
-             * @description Returns only the data from cart line update response
-             * @param cartHdrUid Cart header unique identifier
-             * @param items Array of cart line items to update
-             * @returns Update result (data only)
-             * @throws ValidationError When request is invalid or response is malformed
+             * Update Operations
+             * @description Cart line update functionality for modifying existing items
              */
-            updateData: async (cartHdrUid, items) => {
-                const response = await this.cartLines.update(cartHdrUid, items);
-                return response.data;
+            update: {
+                /**
+                 * Update quantities or details for existing cart line items
+                 *
+                 * @fullPath api.commerce.cartLine.update.create
+                 * @service commerce
+                 * @domain cart-management
+                 * @dataMethod cartLine.update.getData - returns only the update result data without metadata
+                 * @discoverable true
+                 * @searchTerms ["update cart line", "modify cart items", "change quantity", "update line items", "cart modification"]
+                 * @relatedEndpoints ["api.commerce.cartLine.get", "api.commerce.cartLine.add.create", "api.commerce.cartLine.lines.delete"]
+                 * @commonPatterns ["Update item quantity", "Modify cart items", "Change line details", "Cart item updates"]
+                 * @workflow ["cart-modification", "quantity-updates", "cart-management"]
+                 * @prerequisites ["Valid cart header UID", "Valid line identification", "Items must exist in cart"]
+                 * @nextSteps ["api.commerce.cartLine.get to view updated cart", "api.commerce.checkout.create to proceed to checkout"]
+                 * @businessRules ["Updates existing line items only", "Validates quantity changes", "Recalculates pricing"]
+                 * @functionalArea "cart-and-session-management"
+                 * @caching "No caching, immediate cart modification"
+                 * @performance "Batch operation for multiple line updates"
+                 *
+                 * @description Updates existing line items in the cart with new quantities, notes, or other modifications
+                 * @param cartHdrUid Cart header unique identifier
+                 * @param items Array of cart line items to update (must specify lineNo or key for identification)
+                 * @returns Promise<CartLineModifyResponse> Complete response with update status and metadata
+                 * @throws ValidationError When request is invalid or response is malformed
+                 *
+                 * @example
+                 * ```typescript
+                 * // Update multiple line items
+                 * const response = await client.cartLine.update.create(789, [
+                 *   {
+                 *     lineNo: 1,
+                 *     quantity: 5.0,
+                 *     lineNote: 'Updated quantity to 5'
+                 *   },
+                 *   {
+                 *     key: 'unique-key-123',
+                 *     quantity: 3.0
+                 *   }
+                 * ]);
+                 *
+                 * // Get just the update result
+                 * const result = await client.cartLine.update.getData(789, items);
+                 * ```
+                 */
+                create: async (cartHdrUid, items) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/cart-line/{cartHdrUid}/update',
+                        responseSchema: schemas_1.CartLineModifyResponseSchema,
+                    }, items, { cartHdrUid: String(cartHdrUid) });
+                },
+                /**
+                 * Update cart line items data only
+                 * @param cartHdrUid Cart header unique identifier
+                 * @param items Array of cart line items to update
+                 * @returns Promise<unknown> Update result data only
+                 */
+                getData: async (cartHdrUid, items) => {
+                    const response = await this.cartLine.update.create(cartHdrUid, items);
+                    return response.data;
+                },
             },
             /**
-             * Clear all cart line items (data only)
-             * @description Returns only the data from cart clear response
+             * Get cart line items data only
              * @param cartHdrUid Cart header unique identifier
-             * @returns Clear result (data only)
-             * @throws ValidationError When response is malformed
+             * @returns Promise<unknown[]> Array of cart line items data only
              */
-            clearData: async (cartHdrUid) => {
-                const response = await this.cartLines.clear(cartHdrUid);
+            getData: async (cartHdrUid) => {
+                const response = await this.cartLine.get(cartHdrUid);
                 return response.data;
             },
             /**
-             * Delete specific cart line item (data only)
-             * @description Returns only the data from cart line deletion response
+             * Clear all cart line items data only
              * @param cartHdrUid Cart header unique identifier
-             * @param lineNo Line number to delete
-             * @returns Deletion result (data only)
-             * @throws ValidationError When response is malformed
+             * @returns Promise<unknown> Clear result data only
              */
-            deleteLineData: async (cartHdrUid, lineNo) => {
-                const response = await this.cartLines.deleteLine(cartHdrUid, lineNo);
+            deleteData: async (cartHdrUid) => {
+                const response = await this.cartLine.delete(cartHdrUid);
                 return response.data;
             },
         };
         /**
-         * Checkout endpoints
-         * @description Methods for end-to-end checkout processing with Prophet21 ERP integration
+         * Checkout Operations
+         * @description End-to-end checkout processing with Prophet21 ERP integration
          */
         this.checkout = {
             /**
              * Create a new checkout session
+             *
+             * @fullPath api.commerce.checkout.create
+             * @service commerce
+             * @domain checkout-processing
+             * @dataMethod checkout.createData - returns only the checkout data without metadata
+             * @discoverable true
+             * @searchTerms ["checkout", "create checkout", "order", "payment", "purchase", "e-commerce", "checkout process"]
+             * @relatedEndpoints ["api.commerce.cartLine.get", "api.commerce.checkout.get", "api.avalara.rates.create", "api.customers.customer.get"]
+             * @commonPatterns ["Create checkout", "Process order", "E-commerce checkout", "Payment processing"]
+             * @workflow ["checkout-creation", "order-processing", "payment-processing", "erp-integration"]
+             * @prerequisites ["Valid cart data", "Customer information", "Payment details", "Line items"]
+             * @nextSteps ["api.commerce.checkout.validate.update to validate", "api.commerce.checkout.activate.update to process payment"]
+             * @businessRules ["Requires complete order data", "Validates customer and payment info", "Creates checkout session"]
+             * @functionalArea "checkout-and-payment-processing"
+             * @caching "No caching, immediate checkout creation"
+             * @performance "Creates checkout session for payment processing"
+             *
              * @description Creates a new checkout with complete order data including customer, payment, and line items
              * @param orderData Complete checkout data with customer information, payment details, and line items
-             * @returns Created checkout with unique identifiers and status
+             * @returns Promise<CheckoutCreateResponse> Created checkout with unique identifiers and status
              * @throws ValidationError When request is invalid or response is malformed
+             *
              * @example
              * ```typescript
-             * const checkout = await client.checkout.create({
+             * // Create a new checkout
+             * const response = await client.checkout.create({
              *   customer: {
              *     customerId: 456,
              *     contactId: 123,
@@ -446,233 +631,404 @@ class CommerceClient extends base_client_1.BaseServiceClient {
              *     billToCity: 'Anytown',
              *     billToState: 'CA',
              *     billToZip: '12345',
-             *     billToCountry: 'US',
-             *     shipToName: 'John Doe',
-             *     shipToAddress1: '123 Main St',
-             *     shipToCity: 'Anytown',
-             *     shipToState: 'CA',
-             *     shipToZip: '12345',
-             *     shipToCountry: 'US'
+             *     billToCountry: 'US'
              *   },
              *   payment: {
              *     paymentType: 'CC',
              *     cardNumber: '4111111111111111',
              *     expirationDate: '12/25',
-             *     cvv: '123',
-             *     cardHolderName: 'John Doe'
+             *     cvv: '123'
              *   },
              *   lineItems: [
              *     { invMastUid: 12345, quantity: 2, unitOfMeasure: 'EA', unitPrice: 29.99 }
              *   ]
              * });
+             *
+             * // Get just the checkout data
+             * const checkout = await client.checkout.createData(orderData);
              * ```
              */
-            create: this.createCreateMethod('/checkout', schemas_1.CheckoutCreateRequestSchema, schemas_1.CheckoutCreateResponseSchema),
+            create: async (orderData) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/checkout',
+                    responseSchema: schemas_1.CheckoutCreateResponseSchema,
+                }, orderData);
+            },
             /**
              * Get checkout details by ID
+             *
+             * @fullPath api.commerce.checkout.get
+             * @service commerce
+             * @domain checkout-processing
+             * @dataMethod checkout.getData - returns only the checkout data without metadata
+             * @discoverable true
+             * @searchTerms ["checkout", "get checkout", "checkout details", "order details", "checkout status"]
+             * @relatedEndpoints ["api.commerce.checkout.create", "api.commerce.checkout.validate.update", "api.commerce.checkout.activate.update"]
+             * @commonPatterns ["Get checkout details", "View order", "Check checkout status", "Order information"]
+             * @workflow ["checkout-retrieval", "order-status-check", "checkout-management"]
+             * @prerequisites ["Valid checkout UID", "Checkout must exist"]
+             * @nextSteps ["api.commerce.checkout.validate.update", "api.commerce.checkout.doc.get for receipt"]
+             * @businessRules ["Returns complete checkout details", "Includes order and processing status", "Available to checkout owner"]
+             * @functionalArea "checkout-and-payment-processing"
+             * @caching "Cache for 5 minutes, invalidate on checkout updates"
+             * @performance "Fast retrieval with complete order data"
+             *
              * @description Retrieves complete details for a specific checkout including all order data
              * @param checkoutUid Checkout unique identifier
-             * @returns Complete checkout details with order data and processing status
+             * @returns Promise<CheckoutGetResponse> Complete checkout details with order data and processing status
              * @throws ValidationError When response is malformed
+             *
              * @example
              * ```typescript
-             * const checkout = await client.checkout.get(12345);
-             * console.log('Checkout:', checkout.checkoutUid, 'Status:', checkout.statusCd);
-             * console.log('Created:', checkout.dateCreated, 'Type:', checkout.checkoutType);
+             * // Get checkout details
+             * const response = await client.checkout.get(12345);
+             * console.log('Checkout:', response.data.checkoutUid, 'Status:', response.data.statusCd);
+             * console.log('Created:', response.data.dateCreated, 'Type:', response.data.checkoutType);
+             *
+             * // Get just the checkout data
+             * const checkout = await client.checkout.getData(12345);
              * ```
              */
-            get: this.createGetMethod('/checkout/{checkoutUid}', schemas_1.CheckoutGetResponseSchema),
+            get: async (checkoutUid) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/checkout/{checkoutUid}',
+                    responseSchema: schemas_1.CheckoutGetResponseSchema,
+                }, undefined, { checkoutUid: String(checkoutUid) });
+            },
             /**
-             * Get formatted checkout document
-             * @description Retrieves the formatted checkout document/receipt for display or printing
-             * @param checkoutUid Checkout unique identifier
-             * @param params Optional parameters including associated cart header UID
-             * @returns Raw checkout document response
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const doc = await client.checkout.getDoc(12345, { cartHdrUid: 789 });
-             * // Process or display the formatted document
-             * ```
+             * Activate Operations
+             * @description Checkout activation functionality for payment processing
              */
-            getDoc: async (checkoutUid, params) => {
-                // Return raw response for document endpoint
-                const response = await this.http.get(`${this.baseUrl}/checkout/${checkoutUid}/doc`, params ? schemas_1.CheckoutDocParamsSchema.parse(params) : undefined);
-                return response;
+            activate: {
+                /**
+                 * Activate and process checkout
+                 *
+                 * @fullPath api.commerce.checkout.activate.update
+                 * @service commerce
+                 * @domain checkout-processing
+                 * @dataMethod checkout.activate.getData - returns only the activation result data without metadata
+                 * @discoverable true
+                 * @searchTerms ["activate checkout", "process payment", "finalize order", "checkout activation", "payment processing"]
+                 * @relatedEndpoints ["api.commerce.checkout.get", "api.commerce.checkout.validate.update", "api.avalara.rates.create"]
+                 * @commonPatterns ["Activate checkout", "Process payment", "Finalize order", "Complete purchase"]
+                 * @workflow ["payment-processing", "order-finalization", "erp-integration", "checkout-completion"]
+                 * @prerequisites ["Valid checkout UID", "Checkout validation passed", "Payment information verified"]
+                 * @nextSteps ["api.commerce.checkout.doc.get for receipt", "Order fulfillment processes"]
+                 * @businessRules ["Processes payment", "Creates orders in Prophet21 ERP", "Updates checkout status"]
+                 * @functionalArea "checkout-and-payment-processing"
+                 * @caching "No caching, immediate payment processing"
+                 * @performance "Payment processing with ERP integration"
+                 *
+                 * @description Activates the checkout, processes payment, and creates orders in Prophet21 ERP system
+                 * @param checkoutUid Checkout unique identifier
+                 * @returns Promise<CheckoutActivateResponse> Activated checkout details with updated status
+                 * @throws ValidationError When response is malformed
+                 *
+                 * @example
+                 * ```typescript
+                 * // Activate checkout and process payment
+                 * const response = await client.checkout.activate.update(12345);
+                 * if (response.data.statusCd === 710) {
+                 *   console.log('Checkout successfully activated and processed');
+                 * }
+                 *
+                 * // Get just the activation result
+                 * const result = await client.checkout.activate.getData(12345);
+                 * ```
+                 */
+                update: async (checkoutUid) => {
+                    return this.executeRequest({
+                        method: 'PUT',
+                        path: '/checkout/{checkoutUid}/activate',
+                        responseSchema: schemas_1.CheckoutActivateResponseSchema,
+                    }, undefined, { checkoutUid: String(checkoutUid) });
+                },
+                /**
+                 * Activate checkout data only
+                 * @param checkoutUid Checkout unique identifier
+                 * @returns Promise<unknown> Activation results data only
+                 */
+                getData: async (checkoutUid) => {
+                    const response = await this.checkout.activate.update(checkoutUid);
+                    return response.data;
+                },
             },
             /**
-             * Validate checkout data
-             * @description Validates checkout data without processing payment or creating orders in Prophet21
-             * @param checkoutUid Checkout unique identifier
-             * @returns Validation results with status, errors, and warnings
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const validation = await client.checkout.validate(12345);
-             * if (validation.data.validationResults?.isValid) {
-             *   console.log('Checkout is valid and ready for activation');
-             * } else {
-             *   console.log('Validation errors:', validation.data.validationResults?.errors);
-             * }
-             * ```
+             * Doc Operations
+             * @description Checkout document functionality for receipts and printing
              */
-            validate: this.createActionMethod('/checkout/{checkoutUid}/validate', 'PUT', schemas_1.CheckoutValidateResponseSchema),
+            doc: {
+                /**
+                 * Get formatted checkout document
+                 *
+                 * @fullPath api.commerce.checkout.doc.get
+                 * @service commerce
+                 * @domain checkout-processing
+                 * @dataMethod checkout.doc.getData - returns the document data directly
+                 * @discoverable true
+                 * @searchTerms ["checkout document", "receipt", "checkout doc", "order receipt", "checkout receipt"]
+                 * @relatedEndpoints ["api.commerce.checkout.get", "api.commerce.checkout.activate.update"]
+                 * @commonPatterns ["Get checkout receipt", "Download order document", "Print checkout", "Order confirmation"]
+                 * @workflow ["receipt-generation", "document-retrieval", "order-confirmation"]
+                 * @prerequisites ["Valid checkout UID", "Checkout must exist", "Document must be available"]
+                 * @nextSteps ["Display or print document", "Email to customer", "Store for records"]
+                 * @businessRules ["Generates formatted receipt", "Includes all order details", "Available after checkout creation"]
+                 * @functionalArea "checkout-and-payment-processing"
+                 * @caching "Cache for 1 hour, document content is static"
+                 * @performance "Fast document retrieval for display or printing"
+                 *
+                 * @description Retrieves the formatted checkout document/receipt for display or printing
+                 * @param checkoutUid Checkout unique identifier
+                 * @param params Optional parameters including associated cart header UID
+                 * @returns Promise<unknown> Raw checkout document response
+                 * @throws ValidationError When response is malformed
+                 *
+                 * @example
+                 * ```typescript
+                 * // Get checkout document
+                 * const response = await client.checkout.doc.get(12345, { cartHdrUid: 789 });
+                 * // Process or display the formatted document
+                 *
+                 * // Get document data directly
+                 * const doc = await client.checkout.doc.getData(12345);
+                 * ```
+                 */
+                get: async (checkoutUid, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/checkout/{checkoutUid}/doc',
+                        responseSchema: schemas_1.CheckoutDocResponseSchema,
+                    }, params, { checkoutUid: String(checkoutUid) });
+                },
+                /**
+                 * Get checkout document data only
+                 * @param checkoutUid Checkout unique identifier
+                 * @param params Optional parameters
+                 * @returns Promise<unknown> Checkout document data only
+                 */
+                getData: async (checkoutUid, params) => {
+                    const response = await this.checkout.doc.get(checkoutUid, params);
+                    return response.data;
+                },
+            },
             /**
-             * Activate and process checkout
-             * @description Activates the checkout, processes payment, and creates orders in Prophet21 ERP system
-             * @param checkoutUid Checkout unique identifier
-             * @returns Activated checkout details with updated status
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const result = await client.checkout.activate(12345);
-             * if (result.data.statusCd === 710) {
-             *   console.log('Checkout successfully activated and processed');
-             * }
-             * ```
+             * Validate Operations
+             * @description Checkout validation functionality for pre-processing verification
              */
-            activate: this.createActionMethod('/checkout/{checkoutUid}/activate', 'PUT', schemas_1.CheckoutActivateResponseSchema),
+            validate: {
+                /**
+                 * Validate checkout data
+                 *
+                 * @fullPath api.commerce.checkout.validate.update
+                 * @service commerce
+                 * @domain checkout-processing
+                 * @dataMethod checkout.validate.getData - returns only the validation result data without metadata
+                 * @discoverable true
+                 * @searchTerms ["validate checkout", "checkout validation", "verify checkout", "pre-process validation"]
+                 * @relatedEndpoints ["api.commerce.checkout.get", "api.commerce.checkout.activate.update", "api.avalara.rates.create"]
+                 * @commonPatterns ["Validate checkout", "Pre-process verification", "Check checkout readiness", "Validation check"]
+                 * @workflow ["checkout-validation", "pre-processing", "verification", "validation-checks"]
+                 * @prerequisites ["Valid checkout UID", "Checkout must exist", "Complete checkout data"]
+                 * @nextSteps ["api.commerce.checkout.activate.update if valid", "Fix validation errors if invalid"]
+                 * @businessRules ["Validates without processing payment", "Checks data completeness", "Returns validation results"]
+                 * @functionalArea "checkout-and-payment-processing"
+                 * @caching "No caching, real-time validation required"
+                 * @performance "Fast validation without payment processing"
+                 *
+                 * @description Validates checkout data without processing payment or creating orders in Prophet21
+                 * @param checkoutUid Checkout unique identifier
+                 * @returns Promise<CheckoutValidateResponse> Validation results with status, errors, and warnings
+                 * @throws ValidationError When response is malformed
+                 *
+                 * @example
+                 * ```typescript
+                 * // Validate checkout
+                 * const response = await client.checkout.validate.update(12345);
+                 * if (response.data.validationResults?.isValid) {
+                 *   console.log('Checkout is valid and ready for activation');
+                 * } else {
+                 *   console.log('Validation errors:', response.data.validationResults?.errors);
+                 * }
+                 *
+                 * // Get just the validation results
+                 * const validation = await client.checkout.validate.getData(12345);
+                 * ```
+                 */
+                update: async (checkoutUid) => {
+                    return this.executeRequest({
+                        method: 'PUT',
+                        path: '/checkout/{checkoutUid}/validate',
+                        responseSchema: schemas_1.CheckoutValidateResponseSchema,
+                    }, undefined, { checkoutUid: String(checkoutUid) });
+                },
+                /**
+                 * Validate checkout data only
+                 * @param checkoutUid Checkout unique identifier
+                 * @returns Promise<unknown> Validation results data only
+                 */
+                getData: async (checkoutUid) => {
+                    const response = await this.checkout.validate.update(checkoutUid);
+                    return response.data;
+                },
+            },
             /**
-             * Create Prophet21 checkout header
-             * @description Creates Prophet21-specific checkout header for ERP integration (partially implemented)
-             * @param checkoutUid Checkout unique identifier
-             * @returns Prophet21 header creation result
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const p21Header = await client.checkout.createProphet21Hdr(12345);
-             * // Note: This endpoint is partially implemented
-             * ```
+             * Prophet21 Hdr Operations
+             * @description Prophet21 ERP integration functionality for checkout headers
              */
-            createProphet21Hdr: this.createActionMethod('/checkout/{checkoutUid}/prophet21-hdr', 'POST', schemas_1.CheckoutProphet21HdrResponseSchema),
-            /**
-             * Add Prophet21 checkout lines
-             * @description Adds line items to Prophet21 checkout header (in early development)
-             * @param checkoutUid Checkout unique identifier
-             * @param prophet21HdrUid Prophet21 header unique identifier
-             * @returns Prophet21 line creation result
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const p21Lines = await client.checkout.addProphet21Lines(12345, 67890);
-             * // Note: This endpoint is in early development
-             * ```
-             */
-            addProphet21Lines: async (checkoutUid, prophet21HdrUid) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/checkout/{checkoutUid}/prophet21-hdr/{prophet21HdrUid}/prophet21-line',
-                    responseSchema: schemas_1.CheckoutProphet21LineResponseSchema,
-                }, undefined, { checkoutUid: String(checkoutUid), prophet21HdrUid: String(prophet21HdrUid) });
+            prophet21Hdr: {
+                /**
+                 * Create Prophet21 checkout header
+                 *
+                 * @fullPath api.commerce.checkout.prophet21Hdr.create
+                 * @service commerce
+                 * @domain erp-integration
+                 * @dataMethod checkout.prophet21Hdr.getData - returns only the Prophet21 header data without metadata
+                 * @discoverable true
+                 * @searchTerms ["prophet21", "erp integration", "checkout header", "p21 header", "erp checkout"]
+                 * @relatedEndpoints ["api.commerce.checkout.get", "api.commerce.checkout.prophet21Hdr.prophet21Line.create"]
+                 * @commonPatterns ["Create ERP header", "Prophet21 integration", "ERP checkout header", "P21 header creation"]
+                 * @workflow ["erp-integration", "prophet21-processing", "checkout-erp-sync"]
+                 * @prerequisites ["Valid checkout UID", "Checkout must exist", "ERP integration configured"]
+                 * @nextSteps ["api.commerce.checkout.prophet21Hdr.prophet21Line.create to add lines"]
+                 * @businessRules ["Creates Prophet21-specific header", "ERP integration endpoint", "Partially implemented"]
+                 * @functionalArea "erp-integration"
+                 * @caching "No caching, immediate ERP integration"
+                 * @performance "ERP integration processing"
+                 *
+                 * @description Creates Prophet21-specific checkout header for ERP integration (partially implemented)
+                 * @param checkoutUid Checkout unique identifier
+                 * @returns Promise<CheckoutProphet21HdrResponse> Prophet21 header creation result
+                 * @throws ValidationError When response is malformed
+                 *
+                 * @example
+                 * ```typescript
+                 * // Create Prophet21 header
+                 * const response = await client.checkout.prophet21Hdr.create(12345);
+                 * // Note: This endpoint is partially implemented
+                 *
+                 * // Get just the header data
+                 * const p21Header = await client.checkout.prophet21Hdr.getData(12345);
+                 * ```
+                 */
+                create: async (checkoutUid) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/checkout/{checkoutUid}/prophet21-hdr',
+                        responseSchema: schemas_1.CheckoutProphet21HdrResponseSchema,
+                    }, undefined, { checkoutUid: String(checkoutUid) });
+                },
+                /**
+                 * Prophet21 Line Operations
+                 * @description Prophet21 ERP integration functionality for checkout line items
+                 */
+                prophet21Line: {
+                    /**
+                     * Add Prophet21 checkout lines
+                     *
+                     * @fullPath api.commerce.checkout.prophet21Hdr.prophet21Line.create
+                     * @service commerce
+                     * @domain erp-integration
+                     * @dataMethod checkout.prophet21Hdr.prophet21Line.getData - returns the Prophet21 line data directly
+                     * @discoverable true
+                     * @searchTerms ["prophet21 lines", "erp line items", "p21 lines", "checkout lines", "erp integration"]
+                     * @relatedEndpoints ["api.commerce.checkout.prophet21Hdr.create", "api.commerce.checkout.get"]
+                     * @commonPatterns ["Add ERP line items", "Prophet21 line integration", "ERP checkout lines", "P21 line creation"]
+                     * @workflow ["erp-integration", "prophet21-processing", "checkout-line-sync"]
+                     * @prerequisites ["Valid checkout UID", "Valid Prophet21 header UID", "ERP integration configured"]
+                     * @nextSteps ["Complete ERP integration process", "Finalize Prophet21 checkout"]
+                     * @businessRules ["Adds line items to Prophet21 header", "ERP integration endpoint", "In early development"]
+                     * @functionalArea "erp-integration"
+                     * @caching "No caching, immediate ERP integration"
+                     * @performance "ERP line item processing"
+                     *
+                     * @description Adds line items to Prophet21 checkout header (in early development)
+                     * @param checkoutUid Checkout unique identifier
+                     * @param prophet21HdrUid Prophet21 header unique identifier
+                     * @returns Promise<CheckoutProphet21LineResponse> Prophet21 line creation result
+                     * @throws ValidationError When response is malformed
+                     *
+                     * @example
+                     * ```typescript
+                     * // Add Prophet21 lines
+                     * const response = await client.checkout.prophet21Hdr.prophet21Line.create(12345, 67890);
+                     * // Note: This endpoint is in early development
+                     *
+                     * // Get just the line data
+                     * const p21Lines = await client.checkout.prophet21Hdr.prophet21Line.getData(12345, 67890);
+                     * ```
+                     */
+                    create: async (checkoutUid, prophet21HdrUid) => {
+                        return this.executeRequest({
+                            method: 'POST',
+                            path: '/checkout/{checkoutUid}/prophet21-hdr/{prophet21HdrUid}/prophet21-line',
+                            responseSchema: schemas_1.CheckoutProphet21LineResponseSchema,
+                        }, undefined, { checkoutUid: String(checkoutUid), prophet21HdrUid: String(prophet21HdrUid) });
+                    },
+                    /**
+                     * Add Prophet21 lines data only
+                     * @param checkoutUid Checkout unique identifier
+                     * @param prophet21HdrUid Prophet21 header unique identifier
+                     * @returns Promise<unknown> Prophet21 lines addition result data only
+                     */
+                    createData: async (checkoutUid, prophet21HdrUid) => {
+                        const response = await this.checkout.prophet21Hdr.prophet21Line.create(checkoutUid, prophet21HdrUid);
+                        return response.data;
+                    },
+                    /**
+                     * Get Prophet21 lines data only
+                     * @param checkoutUid Checkout unique identifier
+                     * @param prophet21HdrUid Prophet21 header unique identifier
+                     * @returns Promise<unknown> Prophet21 lines addition result data only
+                     */
+                    getData: async (checkoutUid, prophet21HdrUid) => {
+                        const response = await this.checkout.prophet21Hdr.prophet21Line.create(checkoutUid, prophet21HdrUid);
+                        return response.data;
+                    },
+                },
+                /**
+                 * Create Prophet21 header data only
+                 * @param checkoutUid Checkout unique identifier
+                 * @returns Promise<unknown> Prophet21 header creation result data only
+                 */
+                createData: async (checkoutUid) => {
+                    const response = await this.checkout.prophet21Hdr.create(checkoutUid);
+                    return response.data;
+                },
+                /**
+                 * Get Prophet21 header data only
+                 * @param checkoutUid Checkout unique identifier
+                 * @returns Promise<unknown> Prophet21 header creation result data only
+                 */
+                getData: async (checkoutUid) => {
+                    const response = await this.checkout.prophet21Hdr.create(checkoutUid);
+                    return response.data;
+                },
             },
-            // Data-only methods for checkout
             /**
-             * Create checkout (data only)
-             * @description Returns only the data from checkout creation response
+             * Create checkout data only
              * @param orderData Complete checkout data
-             * @returns Created checkout details (data only)
-             * @throws ValidationError When request is invalid or response is malformed
+             * @returns Promise<unknown> Created checkout details data only
              */
             createData: async (orderData) => {
                 const response = await this.checkout.create(orderData);
                 return response.data;
             },
             /**
-             * Get checkout details (data only)
-             * @description Returns only the data from checkout details response
+             * Get checkout details data only
              * @param checkoutUid Checkout unique identifier
-             * @returns Checkout details (data only)
-             * @throws ValidationError When response is malformed
+             * @returns Promise<unknown> Checkout details data only
              */
             getData: async (checkoutUid) => {
                 const response = await this.checkout.get(checkoutUid);
                 return response.data;
             },
-            /**
-             * Get checkout document (data only)
-             * @description Returns the checkout document directly
-             * @param checkoutUid Checkout unique identifier
-             * @param params Optional parameters
-             * @returns Checkout document (data only)
-             * @throws ValidationError When response is malformed
-             */
-            getDocData: async (checkoutUid, params) => {
-                return await this.checkout.getDoc(checkoutUid, params);
-            },
-            /**
-             * Validate checkout (data only)
-             * @description Returns only the data from checkout validation response
-             * @param checkoutUid Checkout unique identifier
-             * @returns Validation results (data only)
-             * @throws ValidationError When response is malformed
-             */
-            validateData: async (checkoutUid) => {
-                const response = await this.checkout.validate(checkoutUid);
-                return response.data;
-            },
-            /**
-             * Activate checkout (data only)
-             * @description Returns only the data from checkout activation response
-             * @param checkoutUid Checkout unique identifier
-             * @returns Activation results (data only)
-             * @throws ValidationError When response is malformed
-             */
-            activateData: async (checkoutUid) => {
-                const response = await this.checkout.activate(checkoutUid);
-                return response.data;
-            },
-            /**
-             * Create Prophet21 header (data only)
-             * @description Returns only the data from Prophet21 header creation response
-             * @param checkoutUid Checkout unique identifier
-             * @returns Prophet21 header creation result (data only)
-             * @throws ValidationError When response is malformed
-             */
-            createProphet21HdrData: async (checkoutUid) => {
-                const response = await this.checkout.createProphet21Hdr(checkoutUid);
-                return response.data;
-            },
-            /**
-             * Add Prophet21 lines (data only)
-             * @description Returns the Prophet21 lines addition result directly
-             * @param checkoutUid Checkout unique identifier
-             * @param prophet21HdrUid Prophet21 header unique identifier
-             * @returns Prophet21 lines addition result (data only)
-             * @throws ValidationError When response is malformed
-             */
-            addProphet21LinesData: async (checkoutUid, prophet21HdrUid) => {
-                return await this.checkout.addProphet21Lines(checkoutUid, prophet21HdrUid);
-            },
-        };
-        /**
-         * Check service health (no bearer token required)
-         * @description Monitor service availability and site configuration without authentication overhead
-         * @returns Health check response with site hash and ID for configuration verification
-         * @throws ValidationError When response is malformed
-         * @example
-         * ```typescript
-         * const health = await client.getHealthCheck();
-         * console.log('Service health:', health.status);
-         * console.log('Site ID:', health.data.siteId);
-         * console.log('Site Hash:', health.data.siteHash);
-         * ```
-         */
-        this.getHealthCheck = this.createHealthCheckMethod(schemas_1.HealthCheckResponseSchema);
-        /**
-         * Health Data Operations
-         * @description Direct access to health check data without response metadata
-         */
-        this.healthData = {
-            /**
-             * Get health check data without response metadata
-             * @returns Promise<unknown> Health status data directly
-             */
-            check: async () => {
-                const response = await this.getHealthCheck();
-                return response.data;
-            },
         };
     }
+    getServiceDescription() {
+        return 'Commerce service for e-commerce cart and checkout operations with ERP integration';
+    }
 }
 exports.CommerceClient = CommerceClient;
 //# sourceMappingURL=client.js.map