@simpleapps-com/augur-api
Version:
TypeScript client library for Augur microservices API endpoints
983 lines • 48.3 kB
TypeScript
import { HTTPClient } from '../../core/client';
import { BaseServiceClient } from '../../core/base-client';
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.
*
* @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' });
*
* // Standard methods (full BaseResponse)
* const ordersResponse = await api.orders.oeHdr.lookup({ limit: 10, q: '12345' });
* console.log(`Found ${ordersResponse.total} orders`);
*
* // Data methods (data only)
* const orders = await api.orders.oeHdr.lookupData({ limit: 10, q: '12345' });
* orders.forEach(order => console.log(order.orderNo, order.customerName));
*
* // Get order document with validation
* const orderDoc = await api.orders.oeHdr.getDocument(12345678, { postalCode: '12345' });
*
* // Purchase order workflow
* const pos = await api.orders.poHdr.listData({ complete: 'N', limit: 20 });
* const poDoc = await api.orders.poHdr.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
*/
oeHdr: {
/**
* 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.oeHdr.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.oeHdr.getDocument", "api.customers.customer.list", "api.orders.oeHdrSalesrep.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.oeHdr.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.oeHdr.lookup({
* q: '12345',
* completed: 'N',
* limit: 10
* });
* console.log(`Found ${response.total} orders`);
*
* // Get just the order data
* const orders = await api.orders.oeHdr.lookupData({
* salesrepId: 'REP001',
* limit: 50
* });
*
* // Filter by completion status with caching
* const incompleteOrders = await api.orders.oeHdr.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;
limit?: number | undefined;
offset?: number | undefined;
q?: string | undefined;
orderBy?: string | undefined;
taker?: string | undefined;
class1Id?: string | undefined;
addressId?: string | undefined;
completed?: string | undefined;
dateOrderCompleted?: string | undefined;
salesrepId?: string | undefined;
} | undefined) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
customerId: string;
customerName: string;
orderNo: string | number;
orderDate: string;
completed: string;
jobName?: string | undefined;
requestedDate?: string | undefined;
dateOrderCompleted?: string | null | undefined;
salesrepId?: string | undefined;
}[];
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
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.oeHdr.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.oeHdr.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.oeHdr.getDocument(12345678, {
* postalCode: '12345'
* });
* console.log(`Order ${response.data.orderNo} for ${response.data.customerName}`);
*
* // Get just the document data
* const order = await api.orders.oeHdr.getDocumentData(12345678);
* order.lines.forEach(line => {
* console.log(`${line.itemId}: ${line.qtyOrdered} @ $${line.unitPrice}`);
* });
*
* // Without postal code validation
* const orderDoc = await api.orders.oeHdr.getDocument(12345678);
* ```
*/
getDocument: (orderNo: number, params?: OrderDocumentParams) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
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;
};
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
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
*/
oeHdrSalesrep: {
/**
* 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.oeHdrSalesrep.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.oeHdrSalesrep.getOrderDocument", "api.orders.oeHdr.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.oeHdrSalesrep.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.oeHdrSalesrep.getOrders(12345);
* console.log(`Rep has ${response.data.length} orders`);
*
* // Get just the orders data
* const repOrders = await api.orders.oeHdrSalesrep.getOrdersData(12345);
* const totalValue = repOrders.reduce((sum, order) => sum + order.orderTotal, 0);
* ```
*/
getOrders: (salesrepId: number) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
customerId: string;
customerName: string;
orderNo: string | number;
orderDate: string;
completed: string;
jobName?: string | undefined;
requestedDate?: string | undefined;
dateOrderCompleted?: string | null | undefined;
}[];
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
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.oeHdrSalesrep.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.oeHdrSalesrep.getOrders", "api.orders.oeHdr.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.oeHdrSalesrep.getOrderDocument(12345, 987654);
* console.log(`Order ${response.data.orderNo} - Commission: $${response.data.commissionAmount}`);
*
* // Get just the document data
* const repOrder = await api.orders.oeHdrSalesrep.getOrderDocumentData(12345, 987654);
* console.log(`Territory: ${repOrder.territoryCode}`);
* ```
*/
getOrderDocument: (salesrepId: number, orderNo: number) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
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;
};
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
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
*/
poHdr: {
/**
* 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.poHdr.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.poHdr.get", "api.orders.poHdr.getDocument", "api.orders.poHdr.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.poHdr.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.poHdr.list({
* complete: 'N',
* limit: 50
* });
* console.log(`${response.total} open purchase orders`);
*
* // Get just the PO data
* const openPOs = await api.orders.poHdr.listData({
* complete: 'N',
* vendorId: 'VENDOR001'
* });
* ```
*/
list: (params?: {
edgeCache?: 3 | 2 | 4 | 1 | "1" | 5 | 8 | "2" | "3" | "4" | "5" | "8" | undefined;
limit?: number | undefined;
offset?: number | undefined;
q?: string | undefined;
orderBy?: string | undefined;
locationId?: number | undefined;
complete?: string | undefined;
} | undefined) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
poNo: number;
complete: string;
vendorId: number;
vendorName: string | null;
lines?: unknown[] | undefined;
locationId?: number | undefined;
orderDate?: unknown;
ship2Name?: string | null | undefined;
ship2Add1?: string | null | undefined;
ship2Add2?: string | null | undefined;
totalAmount?: number | undefined;
poHdrUid?: number | undefined;
supplierId?: number | undefined;
supplierName?: string | null | undefined;
divisionId?: number | undefined;
poDate?: string | undefined;
companyNo?: string | undefined;
packingSlipNumber?: unknown;
expedite?: string | undefined;
ackFlag?: string | undefined;
}[];
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
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;
vendorId: number;
vendorName: string | null;
lines?: unknown[] | undefined;
locationId?: number | undefined;
orderDate?: unknown;
ship2Name?: string | null | undefined;
ship2Add1?: string | null | undefined;
ship2Add2?: string | null | undefined;
totalAmount?: number | undefined;
poHdrUid?: number | undefined;
supplierId?: number | undefined;
supplierName?: string | null | undefined;
divisionId?: number | undefined;
poDate?: string | undefined;
companyNo?: string | undefined;
packingSlipNumber?: unknown;
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.poHdr.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.poHdr.list", "api.orders.poHdr.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.poHdr.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.poHdr.get(12345);
* console.log(`PO ${response.data.poNo} - Status: ${response.data.status}`);
*
* // Get just the PO data
* const poDetail = await api.orders.poHdr.getData(12345);
* ```
*/
get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
lines: {
lineNo: number;
invMastUid: number;
itemId: string;
qtyOrdered: number;
qtyReceived: number;
description?: string | undefined;
unitOfMeasure?: string | undefined;
itemDesc?: string | undefined;
serialized?: string | undefined;
primaryBin?: string | undefined;
unitCost?: number | undefined;
qtyOutstanding?: number | undefined;
extendedCost?: number | undefined;
trackBins?: string | undefined;
lotAssignmentRequired?: string | undefined;
}[];
poNo: number;
complete: string;
vendorId: number;
vendorName: string | null;
approved?: string | undefined;
orderDate?: unknown;
requestedDate?: string | undefined;
totalAmount?: number | undefined;
poDate?: string | undefined;
expedite?: string | undefined;
ackFlag?: string | undefined;
currencyId?: string | undefined;
exchangeRate?: number | undefined;
};
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
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: {
lineNo: number;
invMastUid: number;
itemId: string;
qtyOrdered: number;
qtyReceived: number;
description?: string | undefined;
unitOfMeasure?: string | undefined;
itemDesc?: string | undefined;
serialized?: string | undefined;
primaryBin?: string | undefined;
unitCost?: number | undefined;
qtyOutstanding?: number | undefined;
extendedCost?: number | undefined;
trackBins?: string | undefined;
lotAssignmentRequired?: string | undefined;
}[];
poNo: number;
complete: string;
vendorId: number;
vendorName: string | null;
approved?: string | undefined;
orderDate?: unknown;
requestedDate?: string | undefined;
totalAmount?: number | undefined;
poDate?: 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.poHdr.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.poHdr.get", "api.orders.poHdr.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.poHdr.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.poHdr.getDocumentData(12345);
* poDoc.lines.forEach(line => {
* console.log(`${line.itemId}: ${line.qtyOrdered} (${line.qtyReceived} received)`);
* });
* ```
*/
getDocument: (poNo: number) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
lines: {
lineNo: number;
invMastUid: number;
itemId: string;
qtyOrdered: number;
qtyReceived: number;
description?: string | undefined;
unitOfMeasure?: string | undefined;
itemDesc?: string | undefined;
serialized?: string | undefined;
primaryBin?: string | undefined;
unitCost?: number | undefined;
qtyOutstanding?: number | undefined;
extendedCost?: number | undefined;
trackBins?: string | undefined;
lotAssignmentRequired?: string | undefined;
}[];
poNo: number;
vendorId: number;
vendorName: string | null;
receipts?: unknown[] | undefined;
orderDate?: unknown;
totalAmount?: number | undefined;
invoices?: unknown[] | undefined;
poDate?: string | undefined;
vendorAddress?: {
state?: string | undefined;
city?: string | undefined;
address1?: string | undefined;
zip?: string | undefined;
} | undefined;
terms?: string | undefined;
fobPoint?: string | undefined;
};
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
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: {
lineNo: number;
invMastUid: number;
itemId: string;
qtyOrdered: number;
qtyReceived: number;
description?: string | undefined;
unitOfMeasure?: string | undefined;
itemDesc?: string | undefined;
serialized?: string | undefined;
primaryBin?: string | undefined;
unitCost?: number | undefined;
qtyOutstanding?: number | undefined;
extendedCost?: number | undefined;
trackBins?: string | undefined;
lotAssignmentRequired?: string | undefined;
}[];
poNo: number;
vendorId: number;
vendorName: string | null;
receipts?: unknown[] | undefined;
orderDate?: unknown;
totalAmount?: number | undefined;
invoices?: unknown[] | undefined;
poDate?: string | 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.poHdr.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.poHdr.list", "api.orders.poHdr.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.poHdr.scan({
* itemIds: ['ITEM001', 'ITEM002'],
* similarityThreshold: 70
* });
*
* // Get just the scan results
* const similarPOs = await api.orders.poHdr.scanData({
* vendorId: 'VENDOR001',
* dateFrom: '2024-01-01'
* });
* ```
*/
scan: (data: {
locationId?: number | undefined;
complete?: string | undefined;
vendorId?: number | undefined;
dateRange?: {
startDate?: string | undefined;
endDate?: string | undefined;
} | undefined;
itemIds?: string[] | undefined;
minAmount?: number | undefined;
maxAmount?: number | undefined;
}) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
similarity: number;
poNo: number;
vendorId: number;
matchedCriteria: string[];
orderDate?: unknown;
totalAmount?: number | undefined;
poDate?: string | undefined;
}[];
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
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;
vendorId: number;
matchedCriteria: string[];
orderDate?: unknown;
totalAmount?: number | undefined;
poDate?: string | undefined;
}[]>;
};
/**
* Invoice Management Operations
* @description Invoice processing and document management with Prophet 21 integration for billing and accounting workflows
*/
invoiceHdr: {
/**
* 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.invoiceHdr.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.oeHdr.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.invoiceHdr.reprint('INV-12345');
* console.log(`Invoice reprint status: ${response.data.status}`);
*
* // Get just the reprint data
* const reprintResult = await api.orders.invoiceHdr.reprintData('INV-12345');
* if (reprintResult.success) {
* console.log(`Reprint generated: ${reprintResult.documentUrl}`);
* }
* ```
*/
reprint: (invoiceNo: string) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
invoiceNo: string;
reprintStatus: string;
reprintDate: string;
documentPath?: string | undefined;
p21Response?: {
status: string;
documentId?: string | undefined;
} | undefined;
};
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
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[];
data: {
siteHash: string;
siteId: string;
};
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
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