@simpleapps-com/augur-api 0.5.1 → 0.6.0

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

@@ -1,6 +1,6 @@
 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';
+import { type HealthCheckResource, type HealthCheckDataResource, type CartHdrResource, type CartHdrDataResource, type CartLineResource, type CartLineDataResource, type CheckoutResource, type CheckoutDataResource } from './resources';
 /**
  * Commerce Service Client
  * @description Client for interacting with Commerce API endpoints for e-commerce cart and checkout operations
@@ -25,1028 +25,36 @@ import { CartHdrListParams, CartHdrLookupParams, CartHdrLookupResponse, CartLine
  *
  * // Check service health
  * const health = await commerce.healthCheck.get();
- * const healthData = await commerce.healthCheck.getData();
+ * const healthData = await commerce.healthCheckData.get();
  *
  * // Create or lookup cart
  * const cart = await commerce.cartHdr.lookup.get({ userId: 12345, customerId: 456, contactId: 123 });
  *
  * // Add items to cart
- * await commerce.cartLine.add.create(cart.cartHdrUid, [{ invMastUid: 12345, quantity: 2, unitOfMeasure: 'EA' }]);
+ * await commerce.cartLine.add.create(cart.data.cartHdrUid, [{ invMastUid: 12345, quantity: 2, unitOfMeasure: 'EA' }]);
  *
  * // Create checkout
  * const checkout = await commerce.checkout.create({ customer: {...}, payment: {...}, lineItems: [...] });
  * ```
  */
 export declare class CommerceClient extends BaseServiceClient {
+    /** Health check resource */
+    readonly healthCheck: HealthCheckResource;
+    /** Health check data resource (data-only) */
+    readonly healthCheckData: HealthCheckDataResource;
+    /** Cart header resource */
+    readonly cartHdr: CartHdrResource;
+    /** Cart header data resource (data-only) */
+    readonly cartHdrData: CartHdrDataResource;
+    /** Cart line resource */
+    readonly cartLine: CartLineResource;
+    /** Cart line data resource (data-only) */
+    readonly cartLineData: CartLineDataResource;
+    /** Checkout resource */
+    readonly checkout: CheckoutResource;
+    /** Checkout data resource (data-only) */
+    readonly checkoutData: CheckoutDataResource;
     constructor(http: HTTPClient, baseUrl?: string);
     protected getServiceDescription(): string;
-    /**
-     * Health Check Operations
-     * @description System health monitoring and availability verification for Commerce service
-     */
-    healthCheck: {
-        /**
-         * Check service health and availability
-         *
-         * @fullPath api.commerce.healthCheck.get
-         * @service commerce
-         * @domain system-health
-         * @dataMethod healthCheck.getData - returns only the health status data without metadata
-         * @discoverable true
-         * @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"
-         *
-         * @returns Promise<HealthCheckResponse> Service health status
-         *
-         * @example
-         * ```typescript
-         * // 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 health status
-         * const status = await client.healthCheck.getData();
-         * console.log(status); // Direct object access
-         * ```
-         */
-        get: () => 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;
-        }>;
-        /**
-         * Get health check status data only
-         * @returns Promise<unknown> Health status data
-         */
-        getData: () => Promise<unknown>;
-    };
-    /**
-     * Cart Header Operations
-     * @description Cart header management and session tracking functionality
-     */
-    cartHdr: {
-        /**
-         * List Operations
-         * @description Cart header list functionality for user cart retrieval
-         */
-        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: {
-                    customerId: number;
-                    contactId: number;
-                    userId: number;
-                    cartHdrUid: 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 Operations
-         * @description Cart header lookup functionality for cart retrieval or creation
-         */
-        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>;
-        };
-        /**
-         * Also Bought Operations
-         * @description Product recommendation functionality based on cart contents
-         */
-        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 Operations
-     * @description Cart line management for individual items within shopping carts
-     */
-    cartLine: {
-        /**
-         * Retrieve all line items for a specific cart
-         *
-         * @fullPath api.commerce.cartLine.get
-         * @service commerce
-         * @domain cart-management
-         * @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.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.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"
-         * @performance "Fast retrieval, includes product joins for display"
-         *
-         * @description Returns all line items in a cart with product details, quantities, and pricing
-         * @param cartHdrUid Cart header unique identifier
-         * @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.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.cartLine.getData(789);
-         * ```
-         */
-        get: (cartHdrUid: number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                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;
-            }[];
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Remove all line items from the cart
-         *
-         * @fullPath api.commerce.cartLine.delete
-         * @service commerce
-         * @domain cart-management
-         * @dataMethod cartLine.deleteData - returns only the delete result data without metadata
-         * @discoverable true
-         * @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 "Fast bulk delete operation"
-         *
-         * @description Clears all line items from the specified cart, leaving the cart header intact
-         * @param cartHdrUid Cart header unique identifier
-         * @returns Promise<CartLineModifyResponse> Complete response with deletion status and metadata
-         * @throws ValidationError When response is malformed
-         *
-         * @example
-         * ```typescript
-         * // 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);
-         * ```
-         */
-        delete: (cartHdrUid: number) => Promise<CartLineModifyResponse>;
-        /**
-         * Add Operations
-         * @description Cart line addition functionality for adding items to cart
-         */
-        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>;
-        };
-        /**
-         * Lines Operations
-         * @description Individual cart line management functionality
-         */
-        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 Operations
-         * @description Cart line update functionality for modifying existing items
-         */
-        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>;
-        };
-        /**
-         * Get cart line items data only
-         * @param cartHdrUid Cart header unique identifier
-         * @returns Promise<unknown[]> Array of cart line items data only
-         */
-        getData: (cartHdrUid: number) => Promise<unknown[]>;
-        /**
-         * Clear all cart line items data only
-         * @param cartHdrUid Cart header unique identifier
-         * @returns Promise<unknown> Clear result data only
-         */
-        deleteData: (cartHdrUid: number) => Promise<unknown>;
-    };
-    /**
-     * 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 Promise<CheckoutCreateResponse> Created checkout with unique identifiers and status
-         * @throws ValidationError When request is invalid or response is malformed
-         *
-         * @example
-         * ```typescript
-         * // Create a new checkout
-         * const response = await client.checkout.create({
-         *   customer: {
-         *     customerId: 456,
-         *     contactId: 123,
-         *     billToName: 'John Doe',
-         *     billToAddress1: '123 Main St',
-         *     billToCity: 'Anytown',
-         *     billToState: 'CA',
-         *     billToZip: '12345',
-         *     billToCountry: 'US'
-         *   },
-         *   payment: {
-         *     paymentType: 'CC',
-         *     cardNumber: '4111111111111111',
-         *     expirationDate: '12/25',
-         *     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: (orderData: CheckoutCreateRequest) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                body: string | Record<string, unknown>;
-                checkoutUid: number;
-                checkoutUuid: string;
-                statusCd?: number | undefined;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * 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 Promise<CheckoutGetResponse> Complete checkout details with order data and processing status
-         * @throws ValidationError When response is malformed
-         *
-         * @example
-         * ```typescript
-         * // 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: (checkoutUid: number) => Promise<{
-            params: Record<string, unknown> | unknown[];
-            data: {
-                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;
-            };
-            options: Record<string, unknown> | unknown[];
-            status: number;
-            message: string;
-            count: number;
-            total: number;
-            totalResults: number;
-        }>;
-        /**
-         * Activate Operations
-         * @description Checkout activation functionality for payment processing
-         */
-        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>;
-        };
-        /**
-         * Doc Operations
-         * @description Checkout document functionality for receipts and printing
-         */
-        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>;
-        };
-        /**
-         * Validate Operations
-         * @description Checkout validation functionality for pre-processing verification
-         */
-        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>;
-        };
-        /**
-         * Prophet21 Hdr Operations
-         * @description Prophet21 ERP integration functionality for checkout headers
-         */
-        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>;
-            };
-            /**
-             * 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
-         * @param orderData Complete checkout data
-         * @returns Promise<unknown> Created checkout details data only
-         */
-        createData: (orderData: CheckoutCreateRequest) => Promise<unknown>;
-        /**
-         * Get checkout details data only
-         * @param checkoutUid Checkout unique identifier
-         * @returns Promise<unknown> Checkout details data only
-         */
-        getData: (checkoutUid: number) => Promise<unknown>;
-    };
 }
 //# sourceMappingURL=client.d.ts.map