@simpleapps-com/augur-api 0.2.10 → 0.2.12

package/dist/types/services/orders/client.d.ts

@@ -1,35 +1,108 @@
 import { HTTPClient } from '../../core/client';
 import { BaseServiceClient } from '../../core/base-client';
-import { type OrderDocumentParams } from './schemas';
+import { type OrderDocumentParams, type OrderLookupParams, type PurchaseOrderListParams, type PurchaseOrderScanParams } from './schemas';
 /**
  * Orders Service Client
+ * @description Comprehensive order management functionality for the Augur platform covering the complete order lifecycle from creation through fulfillment, including order processing, invoicing, purchase orders, and sales representative management.
  *
- * Provides comprehensive order management functionality for the Augur platform.
- * Handles the complete order lifecycle from creation through fulfillment,
- * including order processing, invoicing, purchase orders, and sales representative management.
+ * @fullPath api.orders
+ * @service orders
+ * @domain order-management
+ * @discoverable true
+ * @searchTerms ["orders", "order management", "purchase orders", "invoices", "sales orders", "order processing", "fulfillment"]
+ * @relatedEndpoints ["api.customers.customer.list", "api.items.products.list", "api.pricing.job-pricing.create", "api.commerce.checkout.process"]
+ * @commonPatterns ["Order lookup", "Order tracking", "Purchase order management", "Invoice processing", "Sales rep orders"]
+ * @functionalArea "order-and-fulfillment-management"
+ * @workflow ["order-processing", "purchase-order-workflow", "invoice-management", "sales-order-lifecycle"]
+ * @businessRules ["Orders require valid customer and items", "Purchase orders track receiving status", "Invoices integrate with Prophet 21", "Access filtered by sales rep permissions"]
+ * @performance "Supports pagination and filtering. Use edgeCache for frequently accessed data."
  *
  * @example
  * ```typescript
  * const api = new AugurAPI({ bearerToken: 'token', siteId: 'site' });
  *
- * // List orders
- * const orders = await api.orders.orders.lookup({ limit: 10, q: '12345' });
+ * // Standard methods (full BaseResponse)
+ * const ordersResponse = await api.orders.orders.lookup({ limit: 10, q: '12345' });
+ * console.log(`Found ${ordersResponse.total} orders`);
  *
- * // Get order document
- * const order = await api.orders.orders.getDocument(12345678, { postalCode: '12345' });
+ * // Data methods (data only)
+ * const orders = await api.orders.orders.lookupData({ limit: 10, q: '12345' });
+ * orders.forEach(order => console.log(order.orderNo, order.customerName));
  *
- * // List purchase orders
- * const pos = await api.orders.purchaseOrders.list({ complete: 'N', limit: 20 });
+ * // Get order document with validation
+ * const orderDoc = await api.orders.orders.getDocument(12345678, { postalCode: '12345' });
+ *
+ * // Purchase order workflow
+ * const pos = await api.orders.purchaseOrders.listData({ complete: 'N', limit: 20 });
+ * const poDoc = await api.orders.purchaseOrders.getDocument(pos[0].poNo);
  * ```
  */
 export declare class OrdersClient extends BaseServiceClient {
+    /**
+     * Create a new OrdersClient instance
+     * @param http Configured HTTPClient instance with authentication
+     * @param baseUrl Base URL for the Orders API (default: https://orders.augur-api.com)
+     */
     constructor(http: HTTPClient, baseUrl?: string);
     /**
      * Order Management Operations (oe-hdr endpoints)
+     * @description Core order management functionality for searching, tracking, and retrieving sales orders
      */
     orders: {
         /**
          * Search and list order headers with flexible filtering options
+         * @description Returns paginated order headers with comprehensive filtering by customer, date, status, sales rep, and search terms. Supports edge caching for improved performance.
+         *
+         * @fullPath api.orders.orders.lookup
+         * @service orders
+         * @domain order-management
+         * @dataMethod lookupData - returns only the order headers array without metadata
+         * @discoverable true
+         * @searchTerms ["order lookup", "search orders", "order list", "find orders", "order search", "sales orders"]
+         * @relatedEndpoints ["api.orders.orders.getDocument", "api.customers.customer.list", "api.orders.salesRep.getOrders"]
+         * @commonPatterns ["Search orders by customer", "Find orders by order number", "List incomplete orders", "Filter by date range"]
+         * @workflow ["order-discovery", "order-status-tracking", "customer-order-history"]
+         * @prerequisites ["Valid authentication token", "Order access permissions"]
+         * @nextSteps ["api.orders.orders.getDocument for full details", "api.customers.customer.get for customer info"]
+         * @businessRules ["Returns only orders accessible to current user/sales rep", "Completed orders may have restricted access", "Search supports partial matches"]
+         * @functionalArea "order-and-fulfillment-management"
+         * @caching "Supports edgeCache parameter (1-8 hours) for frequently accessed order lists"
+         * @performance "Use pagination for large result sets. Filter by specific criteria to improve performance."
+         *
+         * @param params Optional filtering and pagination parameters
+         * @param params.q Search query for order number, customer name, or PO number
+         * @param params.completed Filter by completion status ('Y' for completed, 'N' for incomplete)
+         * @param params.salesrepId Filter orders by specific sales representative ID
+         * @param params.class1Id Filter by customer class/category
+         * @param params.dateOrderCompleted Filter by order completion date (YYYY-MM-DD format)
+         * @param params.limit Maximum number of orders to return (default: 20, max: 100)
+         * @param params.offset Number of items to skip for pagination
+         * @param params.edgeCache Cache duration in hours (1-8) for improved performance
+         * @returns Promise<BaseResponse<OrderHeader[]>> Complete response with order headers and metadata
+         *
+         * @example
+         * ```typescript
+         * // Search orders with full response metadata
+         * const response = await api.orders.orders.lookup({
+         *   q: '12345',
+         *   completed: 'N',
+         *   limit: 10
+         * });
+         * console.log(`Found ${response.total} orders`);
+         *
+         * // Get just the order data
+         * const orders = await api.orders.orders.lookupData({
+         *   salesrepId: 'REP001',
+         *   limit: 50
+         * });
+         *
+         * // Filter by completion status with caching
+         * const incompleteOrders = await api.orders.orders.lookup({
+         *   completed: 'N',
+         *   edgeCache: 2,  // Cache for 2 hours
+         *   orderBy: 'orderDate DESC'
+         * });
+         * ```
          */
         lookup: (params?: {
             edgeCache?: 3 | 2 | 4 | 1 | "1" | 5 | 8 | "2" | "3" | "4" | "5" | "8" | undefined;
@@ -63,8 +136,65 @@ export declare class OrdersClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
+        /**
+         * Get only order headers data without response metadata
+         * @description Data-only version of lookup() method - returns the order headers array directly
+         *
+         * @param params Same parameters as lookup() method
+         * @returns Promise<OrderHeader[]> Direct array of order headers
+         */
+        lookupData: (params?: OrderLookupParams) => Promise<{
+            customerId: string;
+            customerName: string;
+            orderNo: string | number;
+            orderDate: string;
+            completed: string;
+            jobName?: string | undefined;
+            requestedDate?: string | undefined;
+            dateOrderCompleted?: string | null | undefined;
+            salesrepId?: string | undefined;
+        }[]>;
         /**
          * Retrieve complete order document with all related information
+         * @description Returns comprehensive order details including customer info, shipping address, line items, and totals. Includes optional postal code validation for security.
+         *
+         * @fullPath api.orders.orders.getDocument
+         * @service orders
+         * @domain order-management
+         * @dataMethod getDocumentData - returns only the order document without metadata
+         * @discoverable true
+         * @searchTerms ["order document", "order details", "full order", "order with lines", "complete order"]
+         * @relatedEndpoints ["api.orders.orders.lookup", "api.customers.customer.get", "api.items.products.get"]
+         * @commonPatterns ["Get order details", "View complete order", "Order with line items", "Full order document"]
+         * @workflow ["order-review", "order-fulfillment", "customer-service"]
+         * @prerequisites ["Valid order number", "Order access permissions", "Optional postal code for validation"]
+         * @nextSteps ["Process order fulfillment", "Update order status", "Generate invoice"]
+         * @businessRules ["Postal code validation optional but recommended for security", "Access restricted by sales rep permissions", "Includes all order line items and totals"]
+         * @functionalArea "order-and-fulfillment-management"
+         * @performance "Single document retrieval - no pagination needed. Consider caching for frequently accessed orders."
+         *
+         * @param orderNo Order number to retrieve
+         * @param params Optional parameters including postal code validation
+         * @param params.postalCode Optional postal code for additional security validation
+         * @returns Promise<BaseResponse<OrderDocument>> Complete response with full order document
+         *
+         * @example
+         * ```typescript
+         * // Get order document with validation
+         * const response = await api.orders.orders.getDocument(12345678, {
+         *   postalCode: '12345'
+         * });
+         * console.log(`Order ${response.data.orderNo} for ${response.data.customerName}`);
+         *
+         * // Get just the document data
+         * const order = await api.orders.orders.getDocumentData(12345678);
+         * order.lines.forEach(line => {
+         *   console.log(`${line.itemId}: ${line.qtyOrdered} @ $${line.unitPrice}`);
+         * });
+         *
+         * // Without postal code validation
+         * const orderDoc = await api.orders.orders.getDocument(12345678);
+         * ```
          */
         getDocument: (orderNo: number, params?: OrderDocumentParams) => Promise<{
             params: Record<string, unknown> | unknown[];
@@ -102,13 +232,79 @@ export declare class OrdersClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
+        /**
+         * Get only order document data without response metadata
+         * @description Data-only version of getDocument() method - returns the order document directly
+         *
+         * @param orderNo Order number to retrieve
+         * @param params Optional parameters including postal code validation
+         * @returns Promise<OrderDocument> Direct order document object
+         */
+        getDocumentData: (orderNo: number, params?: OrderDocumentParams) => Promise<{
+            customerId: string;
+            lines: {
+                description: string;
+                lineNo: number;
+                invMastUid: number;
+                unitOfMeasure: string;
+                unitPrice: number;
+                itemId: string;
+                qtyAllocated: number;
+                qtyInvoiced: number;
+                qtyOrdered: number;
+                extendedPrice: number;
+            }[];
+            customerName: string;
+            orderNo: number;
+            orderDate: string;
+            completed: string;
+            poNo?: string | undefined;
+            ship2Name?: string | undefined;
+            ship2City?: string | undefined;
+            ship2State?: string | undefined;
+            ship2Zip?: string | undefined;
+            webReferenceNo?: string | undefined;
+            ship2Address1?: string | undefined;
+            freightOut?: number | undefined;
+        }>;
     };
     /**
      * Sales Representative Order Operations
+     * @description Order management functionality specific to sales representatives including territory-based order access and rep-specific reporting
      */
     salesRep: {
         /**
          * Get order list for a specific sales representative
+         * @description Returns all orders associated with a specific sales representative, filtered by territory and permissions. Essential for sales performance tracking and customer relationship management.
+         *
+         * @fullPath api.orders.salesRep.getOrders
+         * @service orders
+         * @domain sales-management
+         * @dataMethod getOrdersData - returns only the orders array without metadata
+         * @discoverable true
+         * @searchTerms ["sales rep orders", "representative orders", "territory orders", "sales orders by rep", "rep performance"]
+         * @relatedEndpoints ["api.orders.salesRep.getOrderDocument", "api.orders.orders.lookup", "api.customers.customer.list"]
+         * @commonPatterns ["Sales rep performance", "Territory management", "Rep order history", "Sales tracking"]
+         * @workflow ["sales-performance-tracking", "territory-management", "commission-calculation"]
+         * @prerequisites ["Valid sales representative ID", "Sales rep access permissions"]
+         * @nextSteps ["api.orders.salesRep.getOrderDocument for details", "Calculate commission totals", "Territory analysis"]
+         * @businessRules ["Returns only orders within rep's territory", "Respects sales hierarchy permissions", "May include completed and pending orders"]
+         * @functionalArea "sales-and-territory-management"
+         * @performance "Territory-filtered results - typically smaller datasets than global order lists"
+         *
+         * @param salesrepId Sales representative ID to retrieve orders for
+         * @returns Promise<BaseResponse<SalesRepOrder[]>> Complete response with rep's orders and metadata
+         *
+         * @example
+         * ```typescript
+         * // Get all orders for a sales rep
+         * const response = await api.orders.salesRep.getOrders(12345);
+         * console.log(`Rep has ${response.data.length} orders`);
+         *
+         * // Get just the orders data
+         * const repOrders = await api.orders.salesRep.getOrdersData(12345);
+         * const totalValue = repOrders.reduce((sum, order) => sum + order.orderTotal, 0);
+         * ```
          */
         getOrders: (salesrepId: number) => Promise<{
             params: Record<string, unknown> | unknown[];
@@ -129,8 +325,56 @@ export declare class OrdersClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
+        /**
+         * Get only sales rep orders data without response metadata
+         * @description Data-only version of getOrders() method - returns the orders array directly
+         *
+         * @param salesrepId Sales representative ID
+         * @returns Promise<SalesRepOrder[]> Direct array of sales rep orders
+         */
+        getOrdersData: (salesrepId: number) => Promise<{
+            customerId: string;
+            customerName: string;
+            orderNo: string | number;
+            orderDate: string;
+            completed: string;
+            jobName?: string | undefined;
+            requestedDate?: string | undefined;
+            dateOrderCompleted?: string | null | undefined;
+        }[]>;
         /**
          * Get specific order document for a sales representative
+         * @description Returns complete order document with sales rep context, including commission details and territory-specific information. Validates that the order belongs to the specified sales representative.
+         *
+         * @fullPath api.orders.salesRep.getOrderDocument
+         * @service orders
+         * @domain sales-management
+         * @dataMethod getOrderDocumentData - returns only the order document without metadata
+         * @discoverable true
+         * @searchTerms ["sales rep order document", "rep order details", "territory order document", "rep order with lines"]
+         * @relatedEndpoints ["api.orders.salesRep.getOrders", "api.orders.orders.getDocument", "api.customers.customer.get"]
+         * @commonPatterns ["Rep order details", "Commission calculation", "Territory order review", "Sales order analysis"]
+         * @workflow ["sales-order-review", "commission-processing", "territory-analysis"]
+         * @prerequisites ["Valid sales rep ID", "Valid order number", "Order must belong to specified rep"]
+         * @nextSteps ["Calculate commission", "Update order status", "Customer follow-up"]
+         * @businessRules ["Order must belong to specified sales rep", "Includes commission and territory data", "Access controlled by sales hierarchy"]
+         * @functionalArea "sales-and-territory-management"
+         * @performance "Single document retrieval with rep validation - efficient for territory-specific access"
+         *
+         * @param salesrepId Sales representative ID
+         * @param orderNo Order number to retrieve
+         * @returns Promise<BaseResponse<SalesRepOrderDocument>> Complete response with rep-specific order document
+         *
+         * @example
+         * ```typescript
+         * // Get order document for specific sales rep
+         * const response = await api.orders.salesRep.getOrderDocument(12345, 987654);
+         * console.log(`Order ${response.data.orderNo} - Commission: $${response.data.commissionAmount}`);
+         *
+         * // Get just the document data
+         * const repOrder = await api.orders.salesRep.getOrderDocumentData(12345, 987654);
+         * console.log(`Territory: ${repOrder.territoryCode}`);
+         * ```
          */
         getOrderDocument: (salesrepId: number, orderNo: number) => Promise<{
             params: Record<string, unknown> | unknown[];
@@ -153,13 +397,75 @@ export declare class OrdersClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
+        /**
+         * Get only sales rep order document data without response metadata
+         * @description Data-only version of getOrderDocument() method - returns the order document directly
+         *
+         * @param salesrepId Sales representative ID
+         * @param orderNo Order number to retrieve
+         * @returns Promise<SalesRepOrderDocument> Direct sales rep order document object
+         */
+        getOrderDocumentData: (salesrepId: number, orderNo: number) => Promise<{
+            customerId: string;
+            lines: unknown[];
+            orderNo: number;
+            orderDate: string;
+            completed: string;
+            jobName?: string | undefined;
+            ship2Name?: string | undefined;
+            pickTickets?: unknown[] | undefined;
+            ship2Address1?: string | undefined;
+            invoices?: unknown[] | undefined;
+        }>;
     };
     /**
      * Purchase Order Operations
+     * @description Comprehensive purchase order management including creation, tracking, receiving, and document generation for procurement workflows
      */
     purchaseOrders: {
         /**
          * List purchase orders with filtering and pagination
+         * @description Returns paginated purchase orders with comprehensive filtering by status, vendor, date ranges, and completion status. Essential for procurement management and receiving workflows.
+         *
+         * @fullPath api.orders.purchaseOrders.list
+         * @service orders
+         * @domain procurement-management
+         * @dataMethod listData - returns only the purchase orders array without metadata
+         * @discoverable true
+         * @searchTerms ["purchase orders", "PO list", "procurement", "vendor orders", "purchase order management", "receiving"]
+         * @relatedEndpoints ["api.orders.purchaseOrders.get", "api.orders.purchaseOrders.getDocument", "api.orders.purchaseOrders.scan", "api.nexus.receiving.list"]
+         * @commonPatterns ["List open POs", "Find POs by vendor", "Track receiving status", "Procurement dashboard"]
+         * @workflow ["procurement-workflow", "purchase-order-lifecycle", "receiving-management"]
+         * @prerequisites ["Valid authentication", "Purchase order access permissions"]
+         * @nextSteps ["api.orders.purchaseOrders.get for details", "api.nexus.receiving.create for receiving", "Update PO status"]
+         * @businessRules ["Filters by completion status", "Supports vendor and date filtering", "Pagination required for large datasets"]
+         * @functionalArea "procurement-and-purchasing"
+         * @performance "Use filtering to reduce result sets. Consider pagination for better performance."
+         *
+         * @param params Optional filtering and pagination parameters
+         * @param params.complete Filter by completion status ('Y' for complete, 'N' for incomplete)
+         * @param params.vendorId Filter by specific vendor ID
+         * @param params.dateFrom Filter POs created from this date (YYYY-MM-DD)
+         * @param params.dateTo Filter POs created to this date (YYYY-MM-DD)
+         * @param params.limit Maximum number of POs to return (default: 20, max: 100)
+         * @param params.offset Number of items to skip for pagination
+         * @returns Promise<BaseResponse<PurchaseOrder[]>> Complete response with purchase orders and metadata
+         *
+         * @example
+         * ```typescript
+         * // List incomplete purchase orders
+         * const response = await api.orders.purchaseOrders.list({
+         *   complete: 'N',
+         *   limit: 50
+         * });
+         * console.log(`${response.total} open purchase orders`);
+         *
+         * // Get just the PO data
+         * const openPOs = await api.orders.purchaseOrders.listData({
+         *   complete: 'N',
+         *   vendorId: 'VENDOR001'
+         * });
+         * ```
          */
         list: (params?: {
             edgeCache?: 3 | 2 | 4 | 1 | "1" | 5 | 8 | "2" | "3" | "4" | "5" | "8" | undefined;
@@ -189,8 +495,55 @@ export declare class OrdersClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
+        /**
+         * Get only purchase orders data without response metadata
+         * @description Data-only version of list() method - returns the purchase orders array directly
+         *
+         * @param params Same parameters as list() method
+         * @returns Promise<PurchaseOrder[]> Direct array of purchase orders
+         */
+        listData: (params?: PurchaseOrderListParams) => Promise<{
+            poNo: number;
+            complete: string;
+            totalAmount: number;
+            vendorId: string;
+            vendorName: string;
+            poDate: string;
+            locationId?: number | undefined;
+            expedite?: string | undefined;
+            ackFlag?: string | undefined;
+        }[]>;
         /**
          * Get detailed purchase order information
+         * @description Returns comprehensive purchase order details including header information, vendor details, status, and summary totals. Used for PO management and tracking.
+         *
+         * @fullPath api.orders.purchaseOrders.get
+         * @service orders
+         * @domain procurement-management
+         * @dataMethod getData - returns only the purchase order detail without metadata
+         * @discoverable true
+         * @searchTerms ["purchase order details", "PO details", "purchase order info", "PO header"]
+         * @relatedEndpoints ["api.orders.purchaseOrders.list", "api.orders.purchaseOrders.getDocument", "api.nexus.receiving.list"]
+         * @commonPatterns ["Get PO details", "View purchase order", "PO status check", "Vendor order info"]
+         * @workflow ["purchase-order-review", "receiving-preparation", "vendor-management"]
+         * @prerequisites ["Valid purchase order number", "PO access permissions"]
+         * @nextSteps ["api.orders.purchaseOrders.getDocument for full details", "Create receiving record", "Update PO status"]
+         * @businessRules ["Returns header-level information only", "Access controlled by permissions", "Status reflects current receiving state"]
+         * @functionalArea "procurement-and-purchasing"
+         * @performance "Single PO retrieval - efficient for header information"
+         *
+         * @param id Purchase order number to retrieve
+         * @returns Promise<BaseResponse<PurchaseOrderDetail>> Complete response with PO details
+         *
+         * @example
+         * ```typescript
+         * // Get PO details
+         * const response = await api.orders.purchaseOrders.get(12345);
+         * console.log(`PO ${response.data.poNo} - Status: ${response.data.status}`);
+         *
+         * // Get just the PO data
+         * const poDetail = await api.orders.purchaseOrders.getData(12345);
+         * ```
          */
         get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
             params: Record<string, unknown> | unknown[];
@@ -226,8 +579,72 @@ export declare class OrdersClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
+        /**
+         * Get only purchase order detail data without response metadata
+         * @description Data-only version of get() method - returns the purchase order detail directly
+         *
+         * @param id Purchase order number to retrieve
+         * @returns Promise<PurchaseOrderDetail> Direct purchase order detail object
+         */
+        getData: (id: number) => Promise<{
+            lines: {
+                description: string;
+                lineNo: number;
+                invMastUid: number;
+                unitOfMeasure: string;
+                itemId: string;
+                qtyOrdered: number;
+                qtyReceived: number;
+                unitCost: number;
+                extendedCost: number;
+            }[];
+            poNo: number;
+            complete: string;
+            totalAmount: number;
+            vendorId: string;
+            vendorName: string;
+            poDate: string;
+            approved?: string | undefined;
+            requestedDate?: string | undefined;
+            expedite?: string | undefined;
+            ackFlag?: string | undefined;
+            currencyId?: string | undefined;
+            exchangeRate?: number | undefined;
+        }>;
         /**
          * Get complete purchase order document with all related information
+         * @description Returns comprehensive purchase order document including header, line items, vendor information, shipping details, and totals. Complete document for receiving and fulfillment processes.
+         *
+         * @fullPath api.orders.purchaseOrders.getDocument
+         * @service orders
+         * @domain procurement-management
+         * @dataMethod getDocumentData - returns only the purchase order document without metadata
+         * @discoverable true
+         * @searchTerms ["purchase order document", "complete PO", "PO with lines", "full purchase order", "PO document"]
+         * @relatedEndpoints ["api.orders.purchaseOrders.get", "api.orders.purchaseOrders.list", "api.nexus.receiving.create"]
+         * @commonPatterns ["Complete PO details", "PO for receiving", "Full purchase order", "PO with line items"]
+         * @workflow ["purchase-order-fulfillment", "receiving-workflow", "vendor-management"]
+         * @prerequisites ["Valid purchase order number", "Document access permissions"]
+         * @nextSteps ["Process receiving", "Create receiving records", "Update line item status"]
+         * @businessRules ["Includes all line items and quantities", "Shows receiving status per line", "Contains vendor and shipping details"]
+         * @functionalArea "procurement-and-purchasing"
+         * @performance "Complete document retrieval - includes all related data in single call"
+         *
+         * @param poNo Purchase order number to retrieve
+         * @returns Promise<BaseResponse<PurchaseOrderDocument>> Complete response with full PO document
+         *
+         * @example
+         * ```typescript
+         * // Get complete PO document
+         * const response = await api.orders.purchaseOrders.getDocument(12345);
+         * console.log(`PO ${response.data.poNo} has ${response.data.lines.length} line items`);
+         *
+         * // Get just the document data
+         * const poDoc = await api.orders.purchaseOrders.getDocumentData(12345);
+         * poDoc.lines.forEach(line => {
+         *   console.log(`${line.itemId}: ${line.qtyOrdered} (${line.qtyReceived} received)`);
+         * });
+         * ```
          */
         getDocument: (poNo: number) => Promise<{
             params: Record<string, unknown> | unknown[];
@@ -266,8 +683,82 @@ export declare class OrdersClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
+        /**
+         * Get only purchase order document data without response metadata
+         * @description Data-only version of getDocument() method - returns the purchase order document directly
+         *
+         * @param poNo Purchase order number to retrieve
+         * @returns Promise<PurchaseOrderDocument> Direct purchase order document object
+         */
+        getDocumentData: (poNo: number) => Promise<{
+            lines: {
+                description: string;
+                lineNo: number;
+                invMastUid: number;
+                unitOfMeasure: string;
+                itemId: string;
+                qtyOrdered: number;
+                qtyReceived: number;
+                unitCost: number;
+                extendedCost: number;
+            }[];
+            poNo: number;
+            totalAmount: number;
+            vendorId: string;
+            vendorName: string;
+            poDate: string;
+            receipts?: unknown[] | undefined;
+            invoices?: unknown[] | undefined;
+            vendorAddress?: {
+                state?: string | undefined;
+                city?: string | undefined;
+                address1?: string | undefined;
+                zip?: string | undefined;
+            } | undefined;
+            terms?: string | undefined;
+            fobPoint?: string | undefined;
+        }>;
         /**
          * Scan for similar purchase orders based on provided criteria
+         * @description Intelligent purchase order discovery that finds similar POs based on items, vendors, or other criteria. Useful for reordering, vendor analysis, and procurement optimization.
+         *
+         * @fullPath api.orders.purchaseOrders.scan
+         * @service orders
+         * @domain procurement-management
+         * @dataMethod scanData - returns only the scan results without metadata
+         * @discoverable true
+         * @searchTerms ["PO scan", "similar purchase orders", "find similar POs", "PO search", "procurement patterns"]
+         * @relatedEndpoints ["api.orders.purchaseOrders.list", "api.orders.purchaseOrders.getDocument", "api.items.products.list"]
+         * @commonPatterns ["Find similar orders", "Reorder analysis", "Vendor pattern analysis", "Procurement optimization"]
+         * @workflow ["procurement-optimization", "reorder-analysis", "vendor-comparison"]
+         * @prerequisites ["Scan criteria parameters", "PO access permissions"]
+         * @nextSteps ["Analyze results for reordering", "Compare vendor patterns", "Optimize procurement"]
+         * @businessRules ["Matches based on provided criteria", "Returns similarity scores", "Filters by date ranges and status"]
+         * @functionalArea "procurement-and-purchasing"
+         * @performance "Advanced search operation - may take longer for complex criteria"
+         *
+         * @param params Scan criteria and parameters
+         * @param params.itemIds Array of item IDs to match against
+         * @param params.vendorId Vendor ID to focus scan on
+         * @param params.dateFrom Start date for scan range
+         * @param params.dateTo End date for scan range
+         * @param params.similarityThreshold Minimum similarity score (0-100)
+         * @returns Promise<BaseResponse<PurchaseOrderScanResult[]>> Complete response with matching POs and similarity scores
+         *
+         * @example
+         * ```typescript
+         * // Scan for similar POs by items
+         * const response = await api.orders.purchaseOrders.scan({
+         *   itemIds: ['ITEM001', 'ITEM002'],
+         *   similarityThreshold: 70
+         * });
+         *
+         * // Get just the scan results
+         * const similarPOs = await api.orders.purchaseOrders.scanData({
+         *   vendorId: 'VENDOR001',
+         *   dateFrom: '2024-01-01'
+         * });
+         * ```
          */
         scan: (data: {
             locationId?: number | undefined;
@@ -297,13 +788,61 @@ export declare class OrdersClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
+        /**
+         * Get only purchase order scan results data without response metadata
+         * @description Data-only version of scan() method - returns the scan results directly
+         *
+         * @param params Same parameters as scan() method
+         * @returns Promise<PurchaseOrderScanResult[]> Direct array of scan results
+         */
+        scanData: (params?: PurchaseOrderScanParams) => Promise<{
+            similarity: number;
+            poNo: number;
+            totalAmount: number;
+            vendorId: string;
+            poDate: string;
+            matchedCriteria: string[];
+        }[]>;
     };
     /**
      * Invoice Management Operations
+     * @description Invoice processing and document management with Prophet 21 integration for billing and accounting workflows
      */
     invoices: {
         /**
          * Reprint an existing invoice through Prophet 21 integration
+         * @description Generates a reprint of an existing invoice through Prophet 21 system integration. Returns invoice document data and reprint status for billing and customer service workflows.
+         *
+         * @fullPath api.orders.invoices.reprint
+         * @service orders
+         * @domain invoice-management
+         * @dataMethod reprintData - returns only the reprint result without metadata
+         * @discoverable true
+         * @searchTerms ["invoice reprint", "reprint invoice", "invoice copy", "duplicate invoice", "invoice document"]
+         * @relatedEndpoints ["api.orders.orders.getDocument", "api.customers.customer.get", "api.p21-core.company.get"]
+         * @commonPatterns ["Reprint invoice", "Customer invoice copy", "Billing document", "Invoice duplicate"]
+         * @workflow ["invoice-management", "customer-service", "billing-workflow"]
+         * @prerequisites ["Valid invoice number", "Invoice exists in Prophet 21", "Reprint permissions"]
+         * @nextSteps ["Deliver invoice to customer", "Update billing records", "Customer service follow-up"]
+         * @businessRules ["Invoice must exist in Prophet 21", "Reprint creates audit trail", "Formatting matches original invoice"]
+         * @functionalArea "billing-and-invoicing"
+         * @performance "Integrates with Prophet 21 - response time depends on P21 system load"
+         *
+         * @param invoiceNo Invoice number to reprint (string format)
+         * @returns Promise<BaseResponse<InvoiceReprintResult>> Complete response with reprint status and document data
+         *
+         * @example
+         * ```typescript
+         * // Reprint an invoice
+         * const response = await api.orders.invoices.reprint('INV-12345');
+         * console.log(`Invoice reprint status: ${response.data.status}`);
+         *
+         * // Get just the reprint data
+         * const reprintResult = await api.orders.invoices.reprintData('INV-12345');
+         * if (reprintResult.success) {
+         *   console.log(`Reprint generated: ${reprintResult.documentUrl}`);
+         * }
+         * ```
          */
         reprint: (invoiceNo: string) => Promise<{
             params: Record<string, unknown> | unknown[];
@@ -324,9 +863,39 @@ export declare class OrdersClient extends BaseServiceClient {
             total: number;
             totalResults: number;
         }>;
+        /**
+         * Get only invoice reprint data without response metadata
+         * @description Data-only version of reprint() method - returns the reprint result directly
+         *
+         * @param invoiceNo Invoice number to reprint
+         * @returns Promise<InvoiceReprintResult> Direct reprint result object
+         */
+        reprintData: (invoiceNo: string) => Promise<{
+            invoiceNo: string;
+            reprintStatus: string;
+            reprintDate: string;
+            documentPath?: string | undefined;
+            p21Response?: {
+                status: string;
+                documentId?: string | undefined;
+            } | undefined;
+        }>;
     };
     /**
      * Health check endpoint
+     * @description Service health and status monitoring endpoint for system diagnostics and uptime verification
+     *
+     * @fullPath api.orders.getHealthCheck
+     * @service orders
+     * @domain system-monitoring
+     * @dataMethod getHealthCheckData - returns only the health check data without metadata
+     * @discoverable true
+     * @searchTerms ["health check", "service status", "orders health", "system status"]
+     * @relatedEndpoints ["api.joomla.getHealthCheck", "api.nexus.getHealthCheck", "api.items.getHealthCheck"]
+     * @commonPatterns ["Check service health", "System monitoring", "Service status"]
+     * @workflow ["system-monitoring", "health-diagnostics"]
+     * @functionalArea "system-operations"
+     * @performance "Lightweight endpoint for monitoring - minimal response time"
      */
     getHealthCheck: () => Promise<{
         params: Record<string, unknown> | unknown[];
@@ -341,5 +910,22 @@ export declare class OrdersClient extends BaseServiceClient {
         total: number;
         totalResults: number;
     }>;
+    /**
+     * Get only health check data without response metadata
+     * @description Data-only version of getHealthCheck() method - returns the health check data directly
+     *
+     * @returns Promise<HealthCheckData> Direct health check data object
+     *
+     * @example
+     * ```typescript
+     * // Get just the health check data
+     * const healthData = await api.orders.getHealthCheckData();
+     * console.log(`Site: ${healthData.siteId} - Hash: ${healthData.siteHash}`);
+     * ```
+     */
+    getHealthCheckData: () => Promise<{
+        siteHash: string;
+        siteId: string;
+    }>;
 }
 //# sourceMappingURL=client.d.ts.map