@simpleapps-com/augur-api
Version:
TypeScript client library for Augur microservices API endpoints
985 lines • 88.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.VMIClient = void 0;
const base_client_1 = require("../../core/base-client");
const zod_1 = require("zod");
const schemas_1 = require("./schemas");
/**
* VMI (Vendor Managed Inventory) API Client
* @description Client for interacting with VMI microservice API endpoints for warehouse and inventory management
* @example
* ```typescript
* import { HTTPClient } from '@augur/api-client/core';
* import { VMIClient } from '@augur/api-client/services/vmi';
*
* const http = new HTTPClient('vmi', { siteId: 'your-site-id', bearerToken: 'your-token' });
* const vmi = new VMIClient(http);
*
* // List warehouses
* const warehouses = await vmi.warehouses.list({ customerId: 12345 });
*
* // Check inventory availability
* const inventory = await vmi.inventory.checkAvailability(123, { q: 'wire' });
* ```
*/
class VMIClient extends base_client_1.BaseServiceClient {
/**
* Create a new VMIClient instance
* @param http Configured HTTPClient instance
* @param baseUrl Base URL for the VMI API (default: https://vmi.augur-api.com)
*/
constructor(http, baseUrl = 'https://vmi.augur-api.com') {
super('vmi', http, baseUrl);
/**
* Health monitoring endpoints
* @description Methods for checking service availability and health status
*/
this.health = {
/**
* Simple health check endpoint that doesn't require authentication
* @description Returns "pong" response for basic connectivity testing
* @returns Simple pong response
* @throws ValidationError When response is malformed
* @example
* ```typescript
* const pong = await client.health.ping();
* console.log(pong.data); // "pong"
* ```
*/
ping: this.createPingMethod(schemas_1.PingResponseSchema),
/**
* Comprehensive health check with authentication and site validation
* @description Validates authentication, site configuration, and triggers seed site jobs
* @returns Health check response with site information
* @throws ValidationError When response is malformed
* @example
* ```typescript
* const health = await client.health.check();
* console.log('Site:', health.data.siteId, 'Hash:', health.data.siteHash);
* ```
*/
check: this.createHealthCheckMethod(schemas_1.HealthCheckResponseSchema),
};
/**
* Warehouse management endpoints
* @description Methods for CRUD operations on warehouses and warehouse configuration
*/
this.warehouses = {
/**
* List warehouses with filtering and pagination
* @description Returns warehouses with optional filtering by customer, user access, and status
* @param params Optional filtering and pagination parameters
* @returns Array of warehouse objects with pagination metadata
* @throws ValidationError When parameters are invalid or response is malformed
* @example
* ```typescript
* // List all warehouses for a customer
* const warehouses = await client.warehouses.list({ customerId: 12345 });
*
* // Search warehouses with pagination
* const results = await client.warehouses.list({
* customerId: 12345,
* q: 'distribution',
* limit: 5,
* offset: 0
* });
*
* // Filter by user access
* const userWarehouses = await client.warehouses.list({
* customerId: 12345,
* usersId: 456
* });
* ```
*/
list: this.createListMethod('/warehouse', schemas_1.WarehouseListParamsSchema, schemas_1.WarehouseListResponseSchema),
/**
* Get warehouse details by ID
* @description Returns detailed information for a specific warehouse
* @param warehouseUid Warehouse unique identifier
* @returns Warehouse details
* @throws ValidationError When response is malformed
* @example
* ```typescript
* const warehouse = await client.warehouses.get(123);
* console.log(warehouse.warehouse_name, warehouse.status_cd);
* ```
*/
get: this.createGetMethod('/warehouse/{id}', schemas_1.WarehouseResponseSchema),
/**
* Create a new warehouse
* @description Creates a new warehouse with specified configuration
* @param request Warehouse creation data
* @returns Created warehouse information
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* const newWarehouse = await client.warehouses.create({
* warehouse_name: 'West Coast Distribution',
* warehouse_desc: 'Primary warehouse for west coast operations',
* customer_id: 12345,
* inv_profile_hdr_uid: 1
* });
* ```
*/
create: this.createCreateMethod('/warehouse', schemas_1.CreateWarehouseRequestSchema, schemas_1.WarehouseResponseSchema),
/**
* Update an existing warehouse
* @description Updates warehouse information with provided data
* @param warehouseUid Warehouse unique identifier
* @param request Warehouse update data
* @returns Updated warehouse information
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* const updated = await client.warehouses.update(123, {
* warehouse_name: 'Updated Warehouse Name',
* warehouse_desc: 'Updated description'
* });
* ```
*/
update: this.createUpdateMethod('/warehouse/{id}', schemas_1.UpdateWarehouseRequestSchema, schemas_1.WarehouseResponseSchema),
/**
* Soft delete a warehouse
* @description Marks warehouse as deleted (sets status_cd to 700) without removing data
* @param warehouseUid Warehouse unique identifier
* @returns Boolean indicating successful deletion
* @throws ValidationError When response is malformed
* @example
* ```typescript
* const deleted = await client.warehouses.delete(123);
* ```
*/
delete: this.createDeleteBooleanMethod('/warehouse/{id}'),
/**
* Enable, disable, or delete a warehouse
* @description Changes warehouse status using status codes (704=active, 705=inactive, 700=deleted)
* @param warehouseUid Warehouse unique identifier
* @param request Status change request with new status code
* @returns Updated warehouse information
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* // Disable warehouse
* await client.warehouses.enable(123, { status_cd: 705 });
*
* // Re-enable warehouse
* await client.warehouses.enable(123, { status_cd: 704 });
*
* // Delete warehouse
* await client.warehouses.enable(123, { status_cd: 700 });
* ```
*/
enable: async (warehouseUid, request) => {
return this.executeRequest({
method: 'PUT',
path: '/warehouse/{id}/enable',
paramsSchema: schemas_1.EnableWarehouseRequestSchema,
responseSchema: schemas_1.WarehouseResponseSchema,
}, request, { id: String(warehouseUid) });
},
// Data-only methods for warehouses
/**
* List warehouses (data only)
* @fullPath api.vmi.warehouses.listData
* @service vmi
* @domain warehouse-management
* @dataMethod Standard method: warehouses.list
* @discoverable true
* @searchTerms ["warehouses", "facilities", "locations", "storage", "inventory-locations"]
* @relatedEndpoints ["api.items.invLoc.list", "api.nexus.transfers.list", "api.legacy.inventory.list"]
* @commonPatterns ["Get all warehouses", "List facilities", "Find storage locations"]
* @workflow ["warehouse-setup", "inventory-management", "location-management"]
* @prerequisites ["Valid authentication token", "Customer ID available"]
* @nextSteps ["api.vmi.warehouse.get for details", "api.vmi.inventory.checkAvailability for stock levels"]
* @businessRules ["Returns only warehouses accessible to authenticated user", "Supports customer-specific filtering"]
* @functionalArea "warehouse-and-inventory-management"
* @caching "Cache for 10 minutes, invalidate on warehouse changes"
* @performance "Supports pagination, use limit parameter for large datasets"
* @description Returns only the data array from warehouses response
* @param params Optional filtering and pagination parameters
* @returns Array of warehouses (data only)
* @throws ValidationError When parameters are invalid or response is malformed
* @example
* ```typescript
* const warehouses = await client.warehouses.listData({ customerId: 12345 });
* console.log(warehouses); // Direct array access
* ```
*/
listData: async (params) => {
const response = await this.warehouses.list(params);
return response.data;
},
/**
* Get warehouse details (data only)
* @fullPath api.vmi.warehouses.getData
* @service vmi
* @domain warehouse-management
* @dataMethod Standard method: warehouses.get
* @discoverable true
* @searchTerms ["warehouse", "facility", "location", "storage-details"]
* @relatedEndpoints ["api.vmi.inventory.checkAvailability", "api.vmi.userAccess.listWarehouseUsers"]
* @commonPatterns ["Get warehouse info", "View facility details"]
* @description Returns only the data from warehouse details response
* @param warehouseUid Warehouse unique identifier
* @returns Warehouse details (data only)
* @throws ValidationError When response is malformed
* @example
* ```typescript
* const warehouse = await client.warehouses.getData(123);
* console.log(warehouse.warehouse_name); // Direct object access
* ```
*/
getData: async (warehouseUid) => {
const response = await this.warehouses.get(warehouseUid);
return response.data;
},
/**
* Create warehouse (data only)
* @fullPath api.vmi.warehouses.createData
* @service vmi
* @domain warehouse-management
* @dataMethod Standard method: warehouses.create
* @discoverable true
* @searchTerms ["create", "new-warehouse", "facility-setup"]
* @relatedEndpoints ["api.vmi.inventoryProfiles.headers.create", "api.vmi.sections.create"]
* @commonPatterns ["Setup new warehouse", "Add facility"]
* @description Returns only the data from warehouse creation response
* @param request Warehouse creation data
* @returns Created warehouse information (data only)
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* const warehouse = await client.warehouses.createData({
* warehouse_name: 'New Facility',
* customer_id: 12345
* });
* console.log(warehouse.warehouse_uid); // Direct access to created ID
* ```
*/
createData: async (request) => {
const response = await this.warehouses.create(request);
return response.data;
},
/**
* Update warehouse (data only)
* @fullPath api.vmi.warehouses.updateData
* @service vmi
* @domain warehouse-management
* @dataMethod Standard method: warehouses.update
* @discoverable true
* @searchTerms ["update", "modify-warehouse", "edit-facility"]
* @relatedEndpoints ["api.vmi.warehouses.get", "api.vmi.warehouses.enable"]
* @commonPatterns ["Update warehouse info", "Modify facility details"]
* @description Returns only the data from warehouse update response
* @param warehouseUid Warehouse unique identifier
* @param request Warehouse update data
* @returns Updated warehouse information (data only)
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* const warehouse = await client.warehouses.updateData(123, {
* warehouse_desc: 'Updated description'
* });
* console.log(warehouse.date_last_modified); // Direct access to updated fields
* ```
*/
updateData: async (warehouseUid, request) => {
const response = await this.warehouses.update(warehouseUid, request);
return response.data;
},
/**
* Enable/disable warehouse (data only)
* @fullPath api.vmi.warehouses.enableData
* @service vmi
* @domain warehouse-management
* @dataMethod Standard method: warehouses.enable
* @discoverable true
* @searchTerms ["enable", "disable", "warehouse-status", "activate-facility"]
* @relatedEndpoints ["api.vmi.warehouses.get", "api.vmi.warehouses.update"]
* @commonPatterns ["Activate warehouse", "Disable facility", "Change warehouse status"]
* @description Returns only the data from warehouse status change response
* @param warehouseUid Warehouse unique identifier
* @param request Status change request
* @returns Updated warehouse information (data only)
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* const warehouse = await client.warehouses.enableData(123, { status_cd: 704 });
* console.log(warehouse.status_cd); // Direct access to updated status
* ```
*/
enableData: async (warehouseUid, request) => {
const response = await this.warehouses.enable(warehouseUid, request);
return response.data;
},
};
/**
* Inventory operation endpoints
* @description Methods for inventory management including availability, adjustments, receiving, and usage tracking
*/
this.inventory = {
/**
* Check inventory availability with search
* @description Searches inventory items in a warehouse with query string matching
* @param warehouseUid Warehouse unique identifier
* @param params Search parameters including required query string
* @returns Array of available inventory items matching search criteria
* @throws ValidationError When parameters are invalid or response is malformed
* @example
* ```typescript
* const items = await client.inventory.checkAvailability(123, { q: 'wire' });
* items.forEach(item => {
* console.log(`${item.item_id}: ${item.qty_on_hand} ${item.default_selling_unit}`);
* });
* ```
*/
checkAvailability: async (warehouseUid, params) => {
return this.executeRequest({
method: 'GET',
path: '/warehouse/{id}/availability',
paramsSchema: schemas_1.InventoryAvailabilityParamsSchema,
responseSchema: schemas_1.InventoryAvailabilityResponseSchema,
}, params, { id: String(warehouseUid) });
},
/**
* Adjust inventory quantities
* @description Sets absolute inventory quantities (not relative changes) with optional reason tracking
* @param warehouseUid Warehouse unique identifier
* @param request Adjustment request containing array of inventory adjustments
* @returns Success response
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* await client.inventory.adjust(123, {
* adjustments: [
* {
* inv_mast_uid: 456,
* qty_on_hand: 200.0,
* reason: 'Physical count adjustment'
* },
* {
* inv_mast_uid: 789,
* qty_on_hand: 150.0,
* reason: 'Damage correction'
* }
* ]
* });
* ```
*/
adjust: async (warehouseUid, request) => {
await this.executeRequest({
method: 'POST',
path: '/warehouse/{id}/adjust',
paramsSchema: schemas_1.InventoryAdjustRequestSchema,
responseSchema: zod_1.z.boolean(),
}, request, { id: String(warehouseUid) });
return true;
},
/**
* Receive inventory into warehouse
* @description Records received inventory with optional purchase order and lot tracking
* @param warehouseUid Warehouse unique identifier
* @param request Receive request containing array of inventory receipts
* @returns Success response
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* await client.inventory.receive(123, {
* receipts: [
* {
* inv_mast_uid: 456,
* qty_received: 50.0,
* po_number: 'PO-2024-001',
* lot_number: 'LOT-456'
* }
* ]
* });
* ```
*/
receive: async (warehouseUid, request) => {
await this.executeRequest({
method: 'POST',
path: '/warehouse/{id}/receive',
paramsSchema: schemas_1.InventoryReceiveRequestSchema,
responseSchema: zod_1.z.boolean(),
}, request, { id: String(warehouseUid) });
return true;
},
/**
* Get replenishment information
* @description Returns items that need replenishment based on min/max quantities
* @param warehouseUid Warehouse unique identifier
* @param params Optional filtering by distributor
* @returns Replenishment information with suggested order quantities
* @throws ValidationError When parameters are invalid or response is malformed
* @example
* ```typescript
* const replenishment = await client.inventory.getReplenishmentInfo(123, { distributorsUid: 789 });
* replenishment.replenishment_items.forEach(item => {
* console.log(`${item.item_id}: Need ${item.suggested_order_qty} (current: ${item.qty_on_hand})`);
* });
* ```
*/
getReplenishmentInfo: async (warehouseUid, params) => {
return this.executeRequest({
method: 'GET',
path: '/warehouse/{id}/replenish',
paramsSchema: schemas_1.ReplenishmentParamsSchema,
responseSchema: schemas_1.ReplenishmentInfoResponseSchema,
}, params, { id: String(warehouseUid) });
},
/**
* Execute inventory replenishment
* @description Places replenishment orders based on min/max/reorder quantities
* @param warehouseUid Warehouse unique identifier
* @param request Replenishment request with distributor and items to restock
* @returns Success response
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* await client.inventory.replenish(123, {
* distributor_uid: 789,
* restock_items: [
* { inv_mast_uid: 456, qty_to_order: 100.0 },
* { inv_mast_uid: 789, qty_to_order: 75.0 }
* ]
* });
* ```
*/
replenish: async (warehouseUid, request) => {
await this.executeRequest({
method: 'POST',
path: '/warehouse/{id}/replenish',
paramsSchema: schemas_1.ReplenishRequestSchema,
responseSchema: zod_1.z.boolean(),
}, request, { id: String(warehouseUid) });
return true;
},
/**
* Transfer inventory between warehouses
* @description Moves inventory from one warehouse to another with quantity tracking
* @param warehouseUid Source warehouse unique identifier
* @param request Transfer request with destination warehouse and items to transfer
* @returns Success response
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* await client.inventory.transfer(123, {
* to_warehouse_uid: 124,
* transfers: [
* {
* inv_mast_uid: 456,
* qty_to_transfer: 25.0,
* reason: 'Stock balancing'
* }
* ]
* });
* ```
*/
transfer: async (warehouseUid, request) => {
await this.executeRequest({
method: 'POST',
path: '/warehouse/{id}/transfer',
paramsSchema: schemas_1.TransferRequestSchema,
responseSchema: zod_1.z.boolean(),
}, request, { id: String(warehouseUid) });
return true;
},
/**
* Record inventory usage
* @description Automatically decrements inventory and creates usage records for job tracking
* @param warehouseUid Warehouse unique identifier
* @param request Usage request with job information and consumed items
* @returns Success response
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* await client.inventory.recordUsage(123, {
* job_description: 'Office Renovation - Building A',
* department: 'Facilities',
* usage_items: [
* {
* inv_mast_uid: 456,
* inv_profile_line_type: 'prophet21',
* qty_used: 5.0
* },
* {
* inv_mast_uid: 789,
* inv_profile_line_type: 'products',
* qty_used: 2.0,
* warranty: {
* model_no: 'MDL-123',
* serial_no: 'SN-456789',
* warranty_type: 'Standard',
* notes: 'Installed in conference room'
* }
* }
* ]
* });
* ```
*/
recordUsage: async (warehouseUid, request) => {
await this.executeRequest({
method: 'POST',
path: '/warehouse/{id}/usage',
paramsSchema: schemas_1.UsageRequestSchema,
responseSchema: zod_1.z.boolean(),
}, request, { id: String(warehouseUid) });
return true;
},
// Data-only methods for inventory operations
/**
* Check inventory availability (data only)
* @fullPath api.vmi.inventory.checkAvailabilityData
* @service vmi
* @domain inventory-management
* @dataMethod Standard method: inventory.checkAvailability
* @discoverable true
* @searchTerms ["inventory", "availability", "stock-check", "item-search"]
* @relatedEndpoints ["api.items.products.list", "api.legacy.inventory.list", "api.vmi.inventory.adjust"]
* @commonPatterns ["Check stock levels", "Search inventory", "Find available items"]
* @workflow ["inventory-lookup", "stock-verification", "item-availability-check"]
* @prerequisites ["Valid authentication token", "Warehouse access permissions"]
* @nextSteps ["api.vmi.inventory.adjust for quantity changes", "api.vmi.inventory.recordUsage for consumption"]
* @businessRules ["Returns only items matching search query", "Requires warehouse access permissions"]
* @functionalArea "inventory-and-stock-management"
* @caching "Real-time data, do not cache"
* @performance "Use specific search terms to limit results"
* @description Returns only the data array from inventory availability response
* @param warehouseUid Warehouse unique identifier
* @param params Search parameters including query string
* @returns Array of available inventory items (data only)
* @throws ValidationError When parameters are invalid or response is malformed
* @example
* ```typescript
* const items = await client.inventory.checkAvailabilityData(123, { q: 'wire' });
* console.log(items); // Direct array access
* ```
*/
checkAvailabilityData: async (warehouseUid, params) => {
const response = await this.inventory.checkAvailability(warehouseUid, params);
return response.data;
},
/**
* Get replenishment information (data only)
* @fullPath api.vmi.inventory.getReplenishmentInfoData
* @service vmi
* @domain inventory-management
* @dataMethod Standard method: inventory.getReplenishmentInfo
* @discoverable true
* @searchTerms ["replenishment", "restock", "min-max", "reorder-points"]
* @relatedEndpoints ["api.vmi.inventory.replenish", "api.vmi.inventoryProfiles.lines.list"]
* @commonPatterns ["Check restock needs", "Get replenishment suggestions", "Find low inventory"]
* @workflow ["replenishment-planning", "inventory-optimization", "stock-level-monitoring"]
* @prerequisites ["Valid authentication token", "Warehouse access permissions", "Inventory profiles configured"]
* @nextSteps ["api.vmi.inventory.replenish to execute restocking", "api.vmi.inventory.adjust for manual corrections"]
* @businessRules ["Based on min/max quantities from inventory profiles", "Considers current stock levels and demand"]
* @functionalArea "inventory-and-replenishment-management"
* @caching "Cache for 5 minutes, invalidate on inventory changes"
* @performance "May be slow for large inventories, consider filtering by distributor"
* @description Returns only the data from replenishment information response
* @param warehouseUid Warehouse unique identifier
* @param params Optional filtering by distributor
* @returns Replenishment information with suggested quantities (data only)
* @throws ValidationError When parameters are invalid or response is malformed
* @example
* ```typescript
* const replenish = await client.inventory.getReplenishmentInfoData(123);
* console.log(replenish.replenishment_items); // Direct access to restock suggestions
* ```
*/
getReplenishmentInfoData: async (warehouseUid, params) => {
const response = await this.inventory.getReplenishmentInfo(warehouseUid, params);
return response.data;
},
};
/**
* Distributor management endpoints
* @description Methods for CRUD operations on distributors and supplier relationships
*/
this.distributors = {
/**
* List distributors with filtering
* @description Returns distributors for a customer with optional status filtering and pagination
* @param params Filtering and pagination parameters (customerId is required)
* @returns Array of distributor objects
* @throws ValidationError When parameters are invalid or response is malformed
* @example
* ```typescript
* const distributors = await client.distributors.list({ customerId: 12345 });
* distributors.forEach(dist => {
* console.log(`${dist.distributor_name}: ${dist.contact_email}`);
* });
* ```
*/
list: this.createListMethod('/distributors', schemas_1.DistributorListParamsSchema, schemas_1.DistributorListResponseSchema),
/**
* Get distributor details by ID
* @description Returns detailed information for a specific distributor
* @param distributorsUid Distributor unique identifier
* @returns Distributor details
* @throws ValidationError When response is malformed
* @example
* ```typescript
* const distributor = await client.distributors.get(789);
* console.log(distributor.distributor_name, distributor.contact_email);
* ```
*/
get: this.createGetMethod('/distributors/{id}', schemas_1.DistributorResponseSchema),
/**
* Create a new distributor
* @description Creates a new distributor with contact information
* @param request Distributor creation data
* @returns Created distributor information
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* const distributor = await client.distributors.create({
* distributor_name: 'ABC Supply Co',
* distributor_desc: 'Primary electrical supplier',
* customer_id: 12345,
* contact_email: 'orders@abcsupply.com',
* contact_phone: '555-1234'
* });
* ```
*/
create: this.createCreateMethod('/distributors', schemas_1.CreateDistributorRequestSchema, schemas_1.DistributorResponseSchema),
/**
* Update distributor information
* @description Updates distributor details with provided data
* @param distributorsUid Distributor unique identifier
* @param request Distributor update data
* @returns Updated distributor information
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* const updated = await client.distributors.update(789, {
* contact_email: 'newemail@abcsupply.com',
* contact_phone: '555-9999'
* });
* ```
*/
update: this.createUpdateMethod('/distributors/{id}', schemas_1.UpdateDistributorRequestSchema, schemas_1.DistributorResponseSchema),
/**
* Soft delete a distributor
* @description Marks distributor as deleted without removing data
* @param distributorsUid Distributor unique identifier
* @returns Boolean indicating successful deletion
* @throws ValidationError When response is malformed
* @example
* ```typescript
* const deleted = await client.distributors.delete(789);
* ```
*/
delete: this.createDeleteBooleanMethod('/distributors/{id}'),
/**
* Enable, disable, or delete a distributor
* @description Changes distributor status using status codes
* @param distributorsUid Distributor unique identifier
* @param request Status change request with new status code
* @returns Updated distributor information
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* await client.distributors.enable(789, { status_cd: 705 }); // Disable
* await client.distributors.enable(789, { status_cd: 704 }); // Enable
* ```
*/
enable: async (distributorsUid, request) => {
return this.executeRequest({
method: 'PUT',
path: '/distributors/{id}/enable',
paramsSchema: schemas_1.EnableDistributorRequestSchema,
responseSchema: schemas_1.DistributorResponseSchema,
}, request, { id: String(distributorsUid) });
},
// Data-only methods for distributors
/**
* List distributors (data only)
* @fullPath api.vmi.distributors.listData
* @service vmi
* @domain supplier-management
* @dataMethod Standard method: distributors.list
* @discoverable true
* @searchTerms ["distributors", "suppliers", "vendors", "partners"]
* @relatedEndpoints ["api.vmi.products.list", "api.vmi.inventory.replenish", "api.vmi.restocking.list"]
* @commonPatterns ["Get all suppliers", "List vendors", "Find distributors"]
* @workflow ["supplier-management", "vendor-setup", "distributor-onboarding"]
* @prerequisites ["Valid authentication token", "Customer ID available"]
* @nextSteps ["api.vmi.distributors.get for details", "api.vmi.products.list for distributor products"]
* @businessRules ["Returns only distributors associated with customer", "Supports status filtering"]
* @functionalArea "supplier-and-vendor-management"
* @caching "Cache for 15 minutes, invalidate on distributor changes"
* @performance "Supports pagination for large distributor lists"
* @description Returns only the data array from distributors response
* @param params Filtering and pagination parameters
* @returns Array of distributors (data only)
* @throws ValidationError When parameters are invalid or response is malformed
* @example
* ```typescript
* const distributors = await client.distributors.listData({ customerId: 12345 });
* console.log(distributors); // Direct array access
* ```
*/
listData: async (params) => {
const response = await this.distributors.list(params);
return response.data;
},
/**
* Get distributor details (data only)
* @fullPath api.vmi.distributors.getData
* @service vmi
* @domain supplier-management
* @dataMethod Standard method: distributors.get
* @discoverable true
* @searchTerms ["distributor", "supplier", "vendor", "partner-details"]
* @relatedEndpoints ["api.vmi.products.list", "api.vmi.inventory.getReplenishmentInfo"]
* @commonPatterns ["Get supplier info", "View distributor details"]
* @description Returns only the data from distributor details response
* @param distributorsUid Distributor unique identifier
* @returns Distributor details (data only)
* @throws ValidationError When response is malformed
* @example
* ```typescript
* const distributor = await client.distributors.getData(789);
* console.log(distributor.distributors_name); // Direct object access
* ```
*/
getData: async (distributorsUid) => {
const response = await this.distributors.get(distributorsUid);
return response.data;
},
/**
* Create distributor (data only)
* @fullPath api.vmi.distributors.createData
* @service vmi
* @domain supplier-management
* @dataMethod Standard method: distributors.create
* @discoverable true
* @searchTerms ["create", "new-distributor", "add-supplier"]
* @relatedEndpoints ["api.vmi.products.createForDistributor", "api.vmi.restocking.create"]
* @commonPatterns ["Add new supplier", "Setup distributor"]
* @description Returns only the data from distributor creation response
* @param request Distributor creation data
* @returns Created distributor information (data only)
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* const distributor = await client.distributors.createData({
* distributors_name: 'ABC Supply Co',
* customer_id: 12345
* });
* console.log(distributor.distributors_uid); // Direct access to created ID
* ```
*/
createData: async (request) => {
const response = await this.distributors.create(request);
return response.data;
},
/**
* Update distributor (data only)
* @fullPath api.vmi.distributors.updateData
* @service vmi
* @domain supplier-management
* @dataMethod Standard method: distributors.update
* @discoverable true
* @searchTerms ["update", "modify-distributor", "edit-supplier"]
* @relatedEndpoints ["api.vmi.distributors.get", "api.vmi.distributors.enable"]
* @commonPatterns ["Update supplier info", "Modify distributor details"]
* @description Returns only the data from distributor update response
* @param distributorsUid Distributor unique identifier
* @param request Distributor update data
* @returns Updated distributor information (data only)
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* const distributor = await client.distributors.updateData(789, {
* distributors_email: 'new@email.com'
* });
* console.log(distributor.date_last_modified); // Direct access to updated fields
* ```
*/
updateData: async (distributorsUid, request) => {
const response = await this.distributors.update(distributorsUid, request);
return response.data;
},
/**
* Enable/disable distributor (data only)
* @fullPath api.vmi.distributors.enableData
* @service vmi
* @domain supplier-management
* @dataMethod Standard method: distributors.enable
* @discoverable true
* @searchTerms ["enable", "disable", "distributor-status", "activate-supplier"]
* @relatedEndpoints ["api.vmi.distributors.get", "api.vmi.distributors.update"]
* @commonPatterns ["Activate distributor", "Disable supplier", "Change distributor status"]
* @description Returns only the data from distributor status change response
* @param distributorsUid Distributor unique identifier
* @param request Status change request
* @returns Updated distributor information (data only)
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* const distributor = await client.distributors.enableData(789, { status_cd: 704 });
* console.log(distributor.status_cd); // Direct access to updated status
* ```
*/
enableData: async (distributorsUid, request) => {
const response = await this.distributors.enable(distributorsUid, request);
return response.data;
},
};
/**
* Product management endpoints
* @description Methods for CRUD operations on products and product search functionality
*/
this.products = {
/**
* List products with filtering
* @description Returns products for a customer and distributor with optional filtering and pagination
* @param params Filtering and pagination parameters (customerId and distributorsUid are required)
* @returns Array of product objects
* @throws ValidationError When parameters are invalid or response is malformed
* @example
* ```typescript
* const products = await client.products.list({
* customerId: 12345,
* distributorsUid: 789,
* prefix: 'WIRE',
* limit: 20
* });
* ```
*/
list: this.createListMethod('/products', schemas_1.ProductListParamsSchema, schemas_1.ProductListResponseSchema),
/**
* Search across both VMI products and Prophet 21 items
* @description Searches both VMI custom products and Prophet 21 items with prefix matching
* @param params Search parameters with customer ID and optional prefix filter
* @returns Array of found items with type indicator (limited to 10 results)
* @throws ValidationError When parameters are invalid or response is malformed
* @example
* ```typescript
* const items = await client.products.find({
* customerId: 12345,
* prefix: 'WIRE'
* });
*
* items.forEach(item => {
* console.log(`${item.item_id} (${item.type}): ${item.description}`);
* });
* ```
*/
find: async (params) => {
return this.executeRequest({
method: 'GET',
path: '/products/find',
paramsSchema: schemas_1.ProductFindParamsSchema,
responseSchema: schemas_1.ProductFindResponseSchema,
}, params);
},
/**
* Get product details by ID
* @description Returns detailed information for a specific product
* @param productsUid Product unique identifier
* @returns Product details
* @throws ValidationError When response is malformed
* @example
* ```typescript
* const product = await client.products.get(456);
* console.log(product.product_name, product.product_desc);
* ```
*/
get: this.createGetMethod('/products/{id}', schemas_1.ProductResponseSchema),
/**
* Update product information
* @description Updates product details with provided data
* @param productsUid Product unique identifier
* @param request Product update data
* @returns Updated product information
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* const updated = await client.products.update(456, {
* product_name: 'Updated Product Name',
* product_desc: 'Updated description'
* });
* ```
*/
update: this.createUpdateMethod('/products/{id}', schemas_1.UpdateProductRequestSchema, schemas_1.ProductResponseSchema),
/**
* Soft delete a product
* @description Marks product as deleted without removing data
* @param productsUid Product unique identifier
* @returns Boolean indicating successful deletion
* @throws ValidationError When response is malformed
* @example
* ```typescript
* const deleted = await client.products.delete(456);
* ```
*/
delete: this.createDeleteBooleanMethod('/products/{id}'),
/**
* Enable, disable, or delete a product
* @description Changes product status using status codes
* @param productsUid Product unique identifier
* @param request Status change request with new status code
* @returns Updated product information
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* await client.products.enable(456, { status_cd: 705 }); // Disable
* await client.products.enable(456, { status_cd: 704 }); // Enable
* ```
*/
enable: async (productsUid, request) => {
return this.executeRequest({
method: 'PUT',
path: '/products/{id}/enable',
paramsSchema: schemas_1.EnableProductRequestSchema,
responseSchema: schemas_1.ProductResponseSchema,
}, request, { id: String(productsUid) });
},
/**
* Create product associated with distributor
* @description Creates a new product and associates it with a distributor
* @param distributorsUid Distributor unique identifier
* @param request Product creation data
* @returns Created product information
* @throws ValidationError When request is invalid or response is malformed
* @example
* ```typescript
* const product = await client.products.createForDistributor(789, {
* product_id: 'PROD-001',
* product_name: 'New Product',
* product_desc: 'Product description',
* distributors_uid: 789,
* customer_id: 12345
* });
* ```
*/
createForDistributor: async (distributorsUid, request) => {
return this.executeRequest({
method: 'POST',
path: '/distributors/{id}/products',
paramsSchema: schemas_1.CreateProductRequestSchema,
responseSchema: schemas_1.ProductResponseSchema,
}, request, { id: String(distributorsUid) });
},
// Data-only methods for products
/**
* List products (data only)
* @fullPath api.vmi.products.listData
* @service vmi
* @domain product-management
* @dataMethod Standard method: products.list
* @discoverable true
* @searchTerms ["products", "items", "catalog", "inventory-items"]
* @relatedEndpoints ["api.items.products.list", "api.vmi.inventory.checkAvailability"]
* @commonPatterns ["Get all products", "List catalog items", "Browse inventory products"]
* @description Returns only the data array from products response
* @param params Filtering and pagination parameters
* @returns Array of products (data only)
* @throws ValidationError When parameters are invalid or response is malformed
* @example
* ```typescript
* cons