@simpleapps-com/augur-api 0.3.2 → 0.4.0

package/dist/esm/services/commerce/client.d.ts

@@ -2,8 +2,19 @@ import { BaseServiceClient } from '../../core/base-client';
 import type { HTTPClient } from '../../core/client';
 import { CartHdrListParams, CartHdrLookupParams, CartHdrLookupResponse, CartLineAddRequest, CartLineUpdateRequest, CartLineModifyResponse, CartLineDeleteResponse, AlsoBoughtParams, AlsoBoughtResponse, CheckoutCreateRequest, CheckoutDocParams } from './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';
@@ -12,85 +23,67 @@ import { CartHdrListParams, CartHdrLookupParams, CartHdrLookupResponse, CartLine
  * 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: [...] });
  * ```
  */
 export declare class CommerceClient extends 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: HTTPClient, baseUrl?: string);
+    protected getServiceDescription(): string;
     /**
-     * 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
      */
-    cartHeaders: {
+    healthCheck: {
         /**
-         * Retrieve a list of cart headers for a specific user
+         * Check service health and availability
          *
-         * @fullPath api.commerce.cartHeaders.list
+         * @fullPath api.commerce.healthCheck.get
          * @service commerce
-         * @domain cart-management
-         * @dataMethod listData
+         * @domain system-health
+         * @dataMethod healthCheck.getData - returns only the health status data without metadata
          * @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"
+         * @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 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
+         * @returns Promise<HealthCheckResponse> Service health status
          *
          * @example
          * ```typescript
-         * // Get all carts for a user
-         * const response = await client.cartHeaders.list({ userId: 12345 });
-         * console.log(response.data); // CartHdr[]
+         * // 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
          *
-         * // Get just the data array
-         * const carts = await client.cartHeaders.listData({ userId: 12345 });
-         * carts.forEach(cart => console.log(cart.cartHdrUid, cart.cartToken));
+         * // Get just the health status
+         * const status = await client.healthCheck.getData();
+         * console.log(status); // Direct object access
          * ```
          */
-        list: (params?: {
-            userId: number;
-            edgeCache?: 3 | 2 | 4 | 1 | "1" | 5 | 8 | "2" | "3" | "4" | "5" | "8" | undefined;
-            limit?: number | undefined;
-            offset?: number | undefined;
-        } | undefined) => Promise<{
+        get: () => Promise<{
             params: Record<string, unknown> | unknown[];
             data: {
-                cartHdrUid: number;
-                customerId: number;
-                contactId: number;
-                userId: number;
-                userCartNo: number;
-                dateCreated?: string | undefined;
-                dateLastModified?: string | undefined;
-                statusCd?: number | undefined;
-                sessionId?: string | undefined;
-                emailAddress?: string | undefined;
-                cartToken?: string | null | undefined;
-                version?: number | undefined;
-                processCd?: number | undefined;
-            }[];
+                siteHash: string;
+                siteId: string;
+            };
             options: Record<string, unknown> | unknown[];
             status: number;
             message: string;
@@ -99,202 +92,213 @@ export declare class CommerceClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * Lookup an existing cart or create a new one
-         *
-         * @fullPath api.commerce.cartHeaders.lookup
-         * @service commerce
-         * @domain cart-management
-         * @dataMethod lookupData
-         * @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"
-         *
-         * @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
-         *
-         * @example
-         * ```typescript
-         * // Lookup existing cart
-         * const response = await client.cartHeaders.lookup({
-         *   userId: 12345,
-         *   customerId: 456,
-         *   contactId: 123,
-         *   cartToken: 'abc123'
-         * });
-         * console.log(response.data.cartHdrUid);
-         *
-         * // Create new cart (data method)
-         * const cart = await client.cartHeaders.lookupData({
-         *   userId: 12345,
-         *   customerId: 456,
-         *   contactId: 123
-         * });
-         * ```
+         * Get health check status data only
+         * @returns Promise<unknown> Health status data
          */
-        lookup: (params: CartHdrLookupParams) => Promise<CartHdrLookupResponse>;
-        /**
-         * 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 });
-         * ```
-         */
-        getAlsoBought: (cartHdrUid: number, params?: AlsoBoughtParams) => Promise<AlsoBoughtResponse>;
+        getData: () => Promise<unknown>;
+    };
+    /**
+     * Cart Header Operations
+     * @description Cart header management and session tracking functionality
+     */
+    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: (params: CartHdrListParams) => Promise<{
-            cartHdrUid: number;
-            customerId: number;
-            contactId: number;
-            userId: number;
-            userCartNo: number;
-            dateCreated?: string | undefined;
-            dateLastModified?: string | undefined;
-            statusCd?: number | undefined;
-            sessionId?: string | undefined;
-            emailAddress?: string | undefined;
-            cartToken?: string | null | undefined;
-            version?: number | undefined;
-            processCd?: number | undefined;
-        }[]>;
+        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: (params: CartHdrListParams) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    cartHdrUid: number;
+                    customerId: number;
+                    contactId: number;
+                    userId: number;
+                    userCartNo: number;
+                    dateCreated?: string | undefined;
+                    dateLastModified?: string | undefined;
+                    statusCd?: number | undefined;
+                    sessionId?: string | undefined;
+                    emailAddress?: string | undefined;
+                    cartToken?: string | null | undefined;
+                    version?: number | undefined;
+                    processCd?: number | undefined;
+                }[];
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * 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: (params: CartHdrListParams) => Promise<unknown[]>;
+        };
         /**
-         * 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: (params: CartHdrLookupParams) => Promise<{
-            cartHdrUid: number;
-            customerId: number;
-            contactId: number;
-            userId: number;
-            userCartNo: number;
-            dateCreated?: string | undefined;
-            dateLastModified?: string | undefined;
-            statusCd?: number | undefined;
-            sessionId?: string | undefined;
-            emailAddress?: string | undefined;
-            cartToken?: string | null | undefined;
-            version?: number | undefined;
-            processCd?: number | undefined;
-        }>;
+        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: (params: CartHdrLookupParams) => Promise<CartHdrLookupResponse>;
+            /**
+             * Lookup cart header data only
+             * @param params User, customer, and contact identifiers with optional cart token
+             * @returns Promise<unknown> Cart header details
+             */
+            getData: (params: CartHdrLookupParams) => Promise<unknown>;
+        };
         /**
-         * 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: (cartHdrUid: number, params?: AlsoBoughtParams) => Promise<{
-            invMastUid: number;
-            itemId: string;
-            deleteFlag: string;
-            baseUnit: string;
-            serialized: string;
-            trackLots: string;
-            inventorySupplier: unknown[];
-            itemUom: {
-                unitOfMeasure: string;
-                unitSize: number;
-            }[];
-            alternateCodes: string[];
-            legacyTags: string[];
-            attributes: unknown[];
-            images: string[];
-            categoryList: number[];
-            userDefined: Record<string, unknown> | unknown[];
-            invMastText: {
-                sequenceNo: number;
-                displayOnWebFlag: string;
-                textTypeCd: number;
-                webDisplayTypeUid: number;
-                webDisplayTypeId: string;
-                webDisplayTypeDesc: string;
-                textValue: string;
-                textTypeDesc?: string | null | undefined;
-            }[];
-            length?: number | null | undefined;
-            itemDesc?: string | null | undefined;
-            displayDesc?: string | null | undefined;
-            extendedDesc?: string | null | undefined;
-            defaultSellingUnit?: string | null | undefined;
-            defaultPurchasingUnit?: string | null | undefined;
-            vndrStock?: number | null | undefined;
-            classId1?: string | null | undefined;
-            classId2?: string | null | undefined;
-            classId3?: string | null | undefined;
-            classId4?: string | null | undefined;
-            classId5?: string | null | undefined;
-            defaultProductGroup?: string | null | undefined;
-            upcOrEan?: string | null | undefined;
-            upcOrEanId?: string | null | undefined;
-            weight?: number | null | undefined;
-            width?: number | null | undefined;
-            height?: number | null | undefined;
-        }[]>;
+        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: (cartHdrUid: number, params?: AlsoBoughtParams) => Promise<AlsoBoughtResponse>;
+            /**
+             * 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: (cartHdrUid: number, params?: AlsoBoughtParams) => Promise<unknown[]>;
+        };
     };
     /**
-     * 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
      */
-    cartLines: {
+    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"
@@ -302,22 +306,22 @@ export declare class CommerceClient extends 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: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+        get: (cartHdrUid: number) => Promise<{
             params: Record<string, unknown> | unknown[];
             data: {
                 lineNo: number;
@@ -342,191 +346,258 @@ export declare class CommerceClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * 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
+         * @performance "Fast bulk delete operation"
          *
-         * @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'
-         *   }
-         * ]);
-         *
-         * // Get just the success boolean
-         * const success = await client.cartLines.addData(789, items);
-         * ```
-         */
-        add: (cartHdrUid: number, items: CartLineAddRequest) => Promise<CartLineModifyResponse>;
-        /**
-         * 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: (cartHdrUid: number, items: CartLineUpdateRequest) => Promise<CartLineModifyResponse>;
-        /**
-         * 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: (id: string | number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: boolean;
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * 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: (cartHdrUid: number, lineNo: number) => Promise<CartLineDeleteResponse>;
+        delete: (cartHdrUid: number) => Promise<CartLineModifyResponse>;
         /**
-         * 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: (cartHdrUid: number) => Promise<{
-            lineNo: number;
-            invMastUid: number;
-            itemId: string;
-            isAssembly: "Y" | "N";
-            invMastUidCount: number;
-            key?: string | null | undefined;
-            dateCreated?: string | undefined;
-            dateLastModified?: string | undefined;
-            cartHdrUid?: number | undefined;
-            quantity?: number | null | undefined;
-            unitOfMeasure?: string | null | undefined;
-            lineNote?: string | null | undefined;
-            unitPrice?: number | null | undefined;
-        }[]>;
+        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: (cartHdrUid: number, items: CartLineAddRequest) => Promise<CartLineModifyResponse>;
+            /**
+             * 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: (cartHdrUid: number, items: CartLineAddRequest) => Promise<unknown>;
+        };
         /**
-         * 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: (cartHdrUid: number, items: CartLineAddRequest) => Promise<boolean>;
+        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: (cartHdrUid: number, lineNo: number) => Promise<CartLineDeleteResponse>;
+            /**
+             * 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: (cartHdrUid: number, lineNo: number) => Promise<unknown>;
+        };
         /**
-         * 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: (cartHdrUid: number, items: CartLineUpdateRequest) => Promise<boolean>;
+        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: (cartHdrUid: number, items: CartLineUpdateRequest) => Promise<CartLineModifyResponse>;
+            /**
+             * 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: (cartHdrUid: number, items: CartLineUpdateRequest) => Promise<unknown>;
+        };
         /**
-         * 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: (cartHdrUid: number) => Promise<boolean>;
+        getData: (cartHdrUid: number) => Promise<unknown[]>;
         /**
-         * 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: (cartHdrUid: number, lineNo: number) => Promise<{
-            message: string;
-            success: boolean;
-        }>;
+        deleteData: (cartHdrUid: number) => Promise<unknown>;
     };
     /**
-     * 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
      */
     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,
@@ -535,272 +606,24 @@ export declare class CommerceClient extends 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: (data: {
-            oeHdr?: {
-                customerId?: number | undefined;
-                userId?: string | number | undefined;
-                customer_id?: number | undefined;
-                shipToZipCode?: string | undefined;
-                ship_to_zip?: string | undefined;
-                ship_to_postal_code?: string | undefined;
-                shipToEmailAddress?: string | undefined;
-                ship_to_email?: string | undefined;
-                customerPoNo?: string | undefined;
-                customer_po_no?: string | undefined;
-                customer_po_number?: string | undefined;
-                class1?: string | null | undefined;
-                class_id1?: string | null | undefined;
-                class2?: string | null | undefined;
-                class_id2?: string | null | undefined;
-                class3?: string | null | undefined;
-                class_id3?: string | null | undefined;
-                class4?: string | null | undefined;
-                class_id4?: string | null | undefined;
-                class5?: string | null | undefined;
-                class_id5?: string | null | undefined;
-                taker?: string | undefined;
-                shippingEstimate?: number | undefined;
-                shipping_estimate?: number | undefined;
-                cartTax?: {
-                    taxAmount?: number | undefined;
-                    tax_amount?: number | undefined;
-                } | undefined;
-                cart_tax?: {
-                    taxAmount?: number | undefined;
-                    tax_amount?: number | undefined;
-                } | undefined;
-                userEmail?: string | undefined;
-                user_email?: string | undefined;
-                user_id?: string | number | undefined;
-            } | undefined;
-            oe_hdr?: {
-                customerId?: number | undefined;
-                userId?: string | number | undefined;
-                customer_id?: number | undefined;
-                shipToZipCode?: string | undefined;
-                ship_to_zip?: string | undefined;
-                ship_to_postal_code?: string | undefined;
-                shipToEmailAddress?: string | undefined;
-                ship_to_email?: string | undefined;
-                customerPoNo?: string | undefined;
-                customer_po_no?: string | undefined;
-                customer_po_number?: string | undefined;
-                class1?: string | null | undefined;
-                class_id1?: string | null | undefined;
-                class2?: string | null | undefined;
-                class_id2?: string | null | undefined;
-                class3?: string | null | undefined;
-                class_id3?: string | null | undefined;
-                class4?: string | null | undefined;
-                class_id4?: string | null | undefined;
-                class5?: string | null | undefined;
-                class_id5?: string | null | undefined;
-                taker?: string | undefined;
-                shippingEstimate?: number | undefined;
-                shipping_estimate?: number | undefined;
-                cartTax?: {
-                    taxAmount?: number | undefined;
-                    tax_amount?: number | undefined;
-                } | undefined;
-                cart_tax?: {
-                    taxAmount?: number | undefined;
-                    tax_amount?: number | undefined;
-                } | undefined;
-                userEmail?: string | undefined;
-                user_email?: string | undefined;
-                user_id?: string | number | undefined;
-            } | undefined;
-            header?: {
-                customerId?: number | undefined;
-                userId?: string | number | undefined;
-                customer_id?: number | undefined;
-                shipToZipCode?: string | undefined;
-                ship_to_zip?: string | undefined;
-                ship_to_postal_code?: string | undefined;
-                shipToEmailAddress?: string | undefined;
-                ship_to_email?: string | undefined;
-                customerPoNo?: string | undefined;
-                customer_po_no?: string | undefined;
-                customer_po_number?: string | undefined;
-                class1?: string | null | undefined;
-                class_id1?: string | null | undefined;
-                class2?: string | null | undefined;
-                class_id2?: string | null | undefined;
-                class3?: string | null | undefined;
-                class_id3?: string | null | undefined;
-                class4?: string | null | undefined;
-                class_id4?: string | null | undefined;
-                class5?: string | null | undefined;
-                class_id5?: string | null | undefined;
-                taker?: string | undefined;
-                shippingEstimate?: number | undefined;
-                shipping_estimate?: number | undefined;
-                cartTax?: {
-                    taxAmount?: number | undefined;
-                    tax_amount?: number | undefined;
-                } | undefined;
-                cart_tax?: {
-                    taxAmount?: number | undefined;
-                    tax_amount?: number | undefined;
-                } | undefined;
-                userEmail?: string | undefined;
-                user_email?: string | undefined;
-                user_id?: string | number | undefined;
-            } | undefined;
-            oeLine?: {
-                lineNo?: number | undefined;
-                invMastUid?: number | undefined;
-                unitOfMeasure?: string | undefined;
-                lineNote?: string | undefined;
-                unitPrice?: number | undefined;
-                itemId?: string | undefined;
-                unitQuantity?: number | undefined;
-                unit_quantity?: number | undefined;
-                qty?: number | undefined;
-                unit_price?: number | undefined;
-                unit_of_measure?: string | undefined;
-                uom?: string | undefined;
-                manualPriceOverride?: "Y" | "N" | undefined;
-                manual_price_override?: "Y" | "N" | undefined;
-                willCall?: "Y" | "N" | undefined;
-                will_call?: "Y" | "N" | undefined;
-                line_note?: string | undefined;
-                note?: string | undefined;
-            }[] | undefined;
-            oe_line?: {
-                lineNo?: number | undefined;
-                invMastUid?: number | undefined;
-                unitOfMeasure?: string | undefined;
-                lineNote?: string | undefined;
-                unitPrice?: number | undefined;
-                itemId?: string | undefined;
-                unitQuantity?: number | undefined;
-                unit_quantity?: number | undefined;
-                qty?: number | undefined;
-                unit_price?: number | undefined;
-                unit_of_measure?: string | undefined;
-                uom?: string | undefined;
-                manualPriceOverride?: "Y" | "N" | undefined;
-                manual_price_override?: "Y" | "N" | undefined;
-                willCall?: "Y" | "N" | undefined;
-                will_call?: "Y" | "N" | undefined;
-                line_note?: string | undefined;
-                note?: string | undefined;
-            }[] | undefined;
-            lines?: {
-                lineNo?: number | undefined;
-                invMastUid?: number | undefined;
-                unitOfMeasure?: string | undefined;
-                lineNote?: string | undefined;
-                unitPrice?: number | undefined;
-                itemId?: string | undefined;
-                unitQuantity?: number | undefined;
-                unit_quantity?: number | undefined;
-                qty?: number | undefined;
-                unit_price?: number | undefined;
-                unit_of_measure?: string | undefined;
-                uom?: string | undefined;
-                manualPriceOverride?: "Y" | "N" | undefined;
-                manual_price_override?: "Y" | "N" | undefined;
-                willCall?: "Y" | "N" | undefined;
-                will_call?: "Y" | "N" | undefined;
-                line_note?: string | undefined;
-                note?: string | undefined;
-            }[] | undefined;
-            notes?: {
-                note?: string | undefined;
-                topic?: string | undefined;
-            } | undefined;
-            payments?: {
-                paymentAccountId?: string | undefined;
-                payment_account_id?: string | undefined;
-                PaymentAccountID?: string | undefined;
-                processor?: string | undefined;
-                lastFour?: string | number | undefined;
-                last_four?: string | number | undefined;
-                LastFour?: string | number | undefined;
-                paymentBrand?: string | undefined;
-                payment_brand?: string | undefined;
-                PaymentBrand?: string | undefined;
-                expirationMonth?: string | number | undefined;
-                expiration_month?: string | number | undefined;
-                ExpirationMonth?: string | number | undefined;
-                expirationYear?: string | number | undefined;
-                expiration_year?: string | number | undefined;
-                ExpirationYear?: string | number | undefined;
-                firstName?: string | undefined;
-                first_name?: string | undefined;
-                lastName?: string | undefined;
-                last_name?: string | undefined;
-                streetAddress1?: string | undefined;
-                street_address1?: string | undefined;
-                streetAddress2?: string | undefined;
-                street_address2?: string | undefined;
-                city?: string | undefined;
-                state?: string | undefined;
-                zipCode?: string | undefined;
-                zip_code?: string | undefined;
-                country?: string | undefined;
-            } | undefined;
-            web?: {
-                webShopperEmail?: string | undefined;
-                webShopperId?: number | undefined;
-            } | undefined;
-            customer?: {
-                customerId: number;
-                contactId: number;
-                billToName: string;
-                billToAddress1: string;
-                billToCity: string;
-                billToState: string;
-                billToZip: string;
-                billToCountry: string;
-                shipToName: string;
-                shipToAddress1: string;
-                shipToCity: string;
-                shipToState: string;
-                shipToZip: string;
-                shipToCountry: string;
-            } | undefined;
-            payment?: {
-                paymentType: string;
-                cardNumber: string;
-                expirationDate: string;
-                cvv: string;
-                cardHolderName: string;
-            } | undefined;
-            shipping?: {
-                shippingMethod: string;
-                shippingInstructions?: string | undefined;
-            } | undefined;
-            lineItems?: {
-                invMastUid: number;
-                quantity: number;
-                unitOfMeasure: string;
-                unitPrice: number;
-            }[] | undefined;
-        }) => Promise<{
+        create: (orderData: CheckoutCreateRequest) => Promise<{
             params: Record<string, unknown> | unknown[];
             data: {
                 body: string | Record<string, unknown>;
@@ -817,18 +640,40 @@ export declare class CommerceClient extends BaseServiceClient {
         }>;
         /**
          * 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: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+        get: (checkoutUid: number) => Promise<{
             params: Record<string, unknown> | unknown[];
             data: {
                 dateCreated: string;
@@ -853,256 +698,355 @@ export declare class CommerceClient extends BaseServiceClient {
             totalResults: number;
         }>;
         /**
-         * 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: (checkoutUid: number, params?: CheckoutDocParams) => Promise<unknown>;
+        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: (checkoutUid: number) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    statusCd: number;
+                    checkoutUid: number;
+                    checkoutUuid: string;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Activate checkout data only
+             * @param checkoutUid Checkout unique identifier
+             * @returns Promise<unknown> Activation results data only
+             */
+            getData: (checkoutUid: number) => Promise<unknown>;
+        };
         /**
-         * 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: (id: string | number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                statusCd: number;
-                checkoutUid: number;
-                checkoutUuid: string;
-                validationResults?: {
-                    errors: string[];
-                    isValid: boolean;
-                    warnings: string[];
-                } | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
+        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: (checkoutUid: number, params?: CheckoutDocParams) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    dateCreated: string;
+                    dateLastModified: string;
+                    statusCd: number;
+                    cartHdrUid: number;
+                    checkoutUid: number;
+                    checkoutUuid: string;
+                    checkoutType?: string | null | undefined;
+                    properties?: {} | null | undefined;
+                    checkoutProcessor?: string | null | undefined;
+                    jsonData?: string | null | undefined;
+                    sourceName?: string | null | undefined;
+                    sourceId?: string | null | undefined;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Get checkout document data only
+             * @param checkoutUid Checkout unique identifier
+             * @param params Optional parameters
+             * @returns Promise<unknown> Checkout document data only
+             */
+            getData: (checkoutUid: number, params?: CheckoutDocParams) => Promise<unknown>;
+        };
         /**
-         * 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: (id: string | number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                statusCd: number;
-                checkoutUid: number;
-                checkoutUuid: string;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
+        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: (checkoutUid: number) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    statusCd: number;
+                    checkoutUid: number;
+                    checkoutUuid: string;
+                    validationResults?: {
+                        errors: string[];
+                        isValid: boolean;
+                        warnings: string[];
+                    } | undefined;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Validate checkout data only
+             * @param checkoutUid Checkout unique identifier
+             * @returns Promise<unknown> Validation results data only
+             */
+            getData: (checkoutUid: number) => Promise<unknown>;
+        };
         /**
-         * 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: (id: string | number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                checkoutUid: number;
-            } & {
-                [k: string]: unknown;
+        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: (checkoutUid: number) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    checkoutUid: number;
+                } & {
+                    [k: string]: unknown;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * 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: (checkoutUid: number, prophet21HdrUid: number) => Promise<{
+                    params: Record<string, unknown> | unknown[];
+                    data: import("zod").objectInputType<{
+                        lineNo: import("zod").ZodNumber;
+                        itemId: import("zod").ZodString;
+                        unitQuantity: import("zod").ZodNumber;
+                        unitOfMeasure: import("zod").ZodString;
+                    }, import("zod").ZodTypeAny, "passthrough">[];
+                    options: Record<string, unknown> | unknown[];
+                    status: number;
+                    message: string;
+                    count: number;
+                    total: number;
+                    totalResults: number;
+                }>;
+                /**
+                 * 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: (checkoutUid: number, prophet21HdrUid: number) => Promise<unknown>;
+                /**
+                 * 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: (checkoutUid: number, prophet21HdrUid: number) => Promise<unknown>;
             };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * 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: (checkoutUid: number, prophet21HdrUid: number) => Promise<unknown>;
+            /**
+             * Create Prophet21 header data only
+             * @param checkoutUid Checkout unique identifier
+             * @returns Promise<unknown> Prophet21 header creation result data only
+             */
+            createData: (checkoutUid: number) => Promise<unknown>;
+            /**
+             * Get Prophet21 header data only
+             * @param checkoutUid Checkout unique identifier
+             * @returns Promise<unknown> Prophet21 header creation result data only
+             */
+            getData: (checkoutUid: number) => Promise<unknown>;
+        };
         /**
-         * 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
-         */
-        createData: (orderData: CheckoutCreateRequest) => Promise<{
-            body: string | Record<string, unknown>;
-            checkoutUid: number;
-            checkoutUuid: string;
-            statusCd?: number | undefined;
-        }>;
-        /**
-         * Get checkout details (data only)
-         * @description Returns only the data from checkout details response
-         * @param checkoutUid Checkout unique identifier
-         * @returns Checkout details (data only)
-         * @throws ValidationError When response is malformed
-         */
-        getData: (checkoutUid: number) => Promise<{
-            dateCreated: string;
-            dateLastModified: string;
-            statusCd: number;
-            cartHdrUid: number;
-            checkoutUid: number;
-            checkoutUuid: string;
-            body?: unknown;
-            checkoutType?: string | undefined;
-            properties?: string | undefined;
-            checkoutProcessor?: string | undefined;
-            jsonData?: string | undefined;
-            sourceName?: string | undefined;
-            sourceId?: string | undefined;
-        }>;
-        /**
-         * 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: (checkoutUid: number, params?: CheckoutDocParams) => Promise<unknown>;
-        /**
-         * 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: (checkoutUid: number) => Promise<{
-            statusCd: number;
-            checkoutUid: number;
-            checkoutUuid: string;
-            validationResults?: {
-                errors: string[];
-                isValid: boolean;
-                warnings: string[];
-            } | undefined;
-        }>;
-        /**
-         * 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
+         * @returns Promise<unknown> Created checkout details data only
          */
-        activateData: (checkoutUid: number) => Promise<{
-            statusCd: number;
-            checkoutUid: number;
-            checkoutUuid: string;
-        }>;
+        createData: (orderData: CheckoutCreateRequest) => Promise<unknown>;
         /**
-         * Create Prophet21 header (data only)
-         * @description Returns only the data from Prophet21 header creation response
+         * Get checkout details data only
          * @param checkoutUid Checkout unique identifier
-         * @returns Prophet21 header creation result (data only)
-         * @throws ValidationError When response is malformed
+         * @returns Promise<unknown> Checkout details data only
          */
-        createProphet21HdrData: (checkoutUid: number) => Promise<{
-            checkoutUid: number;
-        } & {
-            [k: string]: unknown;
-        }>;
-        /**
-         * 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: (checkoutUid: number, prophet21HdrUid: number) => Promise<unknown>;
-    };
-    /**
-     * 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);
-     * ```
-     */
-    getHealthCheck: () => Promise<{
-        params: Record<string, unknown> | unknown[];
-        data: {
-            siteHash: string;
-            siteId: string;
-        };
-        options: Record<string, unknown> | unknown[];
-        status: number;
-        message: string;
-        count: number;
-        total: number;
-        totalResults: number;
-    }>;
-    /**
-     * Health Data Operations
-     * @description Direct access to health check data without response metadata
-     */
-    healthData: {
-        /**
-         * Get health check data without response metadata
-         * @returns Promise<unknown> Health status data directly
-         */
-        check: () => Promise<{
-            siteHash: string;
-            siteId: string;
-        }>;
+        getData: (checkoutUid: number) => Promise<unknown>;
     };
 }
 //# sourceMappingURL=client.d.ts.map