@simpleapps-com/augur-api
Version:
TypeScript client library for Augur microservices API endpoints
1,108 lines • 99.5 kB
TypeScript
import { BaseServiceClient } from '../../core/base-client';
import type { HTTPClient } from '../../core/client';
import type { BaseResponse } from '../../core/base-client';
import { Warehouse, WarehouseListParams, CreateWarehouseRequest, UpdateWarehouseRequest, EnableWarehouseRequest, InventoryAvailability, InventoryAvailabilityParams, InventoryAdjustRequest, InventoryReceiveRequest, ReplenishmentInfo, ReplenishmentParams, ReplenishRequest, TransferRequest, UsageRequest, Distributor, DistributorListParams, CreateDistributorRequest, UpdateDistributorRequest, EnableDistributorRequest, Product, ProductFindItem, ProductListParams, ProductFindParams, CreateProductRequest, EnableProductRequest, InvProfileLine, InvProfileLineListParams, CreateInvProfileLineRequest, UpdateInvProfileLineRequest, InvProfileHdrListParams, CreateInvProfileHdrRequest, UpdateInvProfileHdrRequest, RestockHdrListParams, CreateRestockHdrRequest, UpdateRestockHdrRequest, Section, SectionListParams, CreateSectionRequest, UpdateSectionRequest, EnableSectionRequest, WarehouseUserListParams, CreateWarehouseUserRequest } from './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' });
* ```
*/
export declare class VMIClient extends 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: HTTPClient, baseUrl?: string);
/**
* Health monitoring endpoints
* @description Methods for checking service availability and health status
*/
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: () => Promise<{
params: Record<string, unknown> | unknown[];
data: "pong";
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
total: number;
totalResults: number;
}>;
/**
* 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: () => 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;
}>;
};
/**
* Warehouse management endpoints
* @description Methods for CRUD operations on warehouses and warehouse configuration
*/
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: (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;
customerId?: number | undefined;
statusCd?: number | undefined;
usersId?: number | undefined;
} | undefined) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
customer_id: number;
status_cd: number;
warehouse_uid: number;
warehouse_name: string;
create_cd: string;
update_cd: string;
warehouse_desc?: string | undefined;
inv_profile_hdr_uid?: number | undefined;
}[];
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
total: number;
totalResults: number;
}>;
/**
* 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: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
customer_id: number;
status_cd: number;
warehouse_uid: number;
warehouse_name: string;
create_cd: string;
update_cd: string;
warehouse_desc?: string | undefined;
inv_profile_hdr_uid?: number | undefined;
};
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
total: number;
totalResults: number;
}>;
/**
* 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: (data: {
customer_id: number;
warehouse_name: string;
warehouse_desc?: string | undefined;
inv_profile_hdr_uid?: number | undefined;
}) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
customer_id: number;
status_cd: number;
warehouse_uid: number;
warehouse_name: string;
create_cd: string;
update_cd: string;
warehouse_desc?: string | undefined;
inv_profile_hdr_uid?: number | undefined;
};
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
total: number;
totalResults: number;
}>;
/**
* 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: (id: string | number, data: {
warehouse_name?: string | undefined;
warehouse_desc?: string | undefined;
}) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
customer_id: number;
status_cd: number;
warehouse_uid: number;
warehouse_name: string;
create_cd: string;
update_cd: string;
warehouse_desc?: string | undefined;
inv_profile_hdr_uid?: number | undefined;
};
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
total: number;
totalResults: number;
}>;
/**
* 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: (id: string | number) => Promise<boolean>;
/**
* 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: (warehouseUid: number, request: EnableWarehouseRequest) => Promise<BaseResponse<Warehouse>>;
/**
* 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: (params?: WarehouseListParams) => Promise<{
customer_id: number;
status_cd: number;
warehouse_uid: number;
warehouse_name: string;
create_cd: string;
update_cd: string;
warehouse_desc?: string | undefined;
inv_profile_hdr_uid?: number | undefined;
}[]>;
/**
* 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: (warehouseUid: number) => Promise<{
customer_id: number;
status_cd: number;
warehouse_uid: number;
warehouse_name: string;
create_cd: string;
update_cd: string;
warehouse_desc?: string | undefined;
inv_profile_hdr_uid?: number | undefined;
}>;
/**
* 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: (request: CreateWarehouseRequest) => Promise<{
customer_id: number;
status_cd: number;
warehouse_uid: number;
warehouse_name: string;
create_cd: string;
update_cd: string;
warehouse_desc?: string | undefined;
inv_profile_hdr_uid?: number | undefined;
}>;
/**
* 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: (warehouseUid: number, request: UpdateWarehouseRequest) => Promise<{
customer_id: number;
status_cd: number;
warehouse_uid: number;
warehouse_name: string;
create_cd: string;
update_cd: string;
warehouse_desc?: string | undefined;
inv_profile_hdr_uid?: number | undefined;
}>;
/**
* 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: (warehouseUid: number, request: EnableWarehouseRequest) => Promise<{
customer_id: number;
status_cd: number;
warehouse_uid: number;
warehouse_name: string;
create_cd: string;
update_cd: string;
warehouse_desc?: string | undefined;
inv_profile_hdr_uid?: number | undefined;
}>;
};
/**
* Inventory operation endpoints
* @description Methods for inventory management including availability, adjustments, receiving, and usage tracking
*/
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: (warehouseUid: number, params: InventoryAvailabilityParams) => Promise<BaseResponse<InventoryAvailability[]>>;
/**
* 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: (warehouseUid: number, request: InventoryAdjustRequest) => Promise<boolean>;
/**
* 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: (warehouseUid: number, request: InventoryReceiveRequest) => Promise<boolean>;
/**
* 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: (warehouseUid: number, params?: ReplenishmentParams) => Promise<BaseResponse<ReplenishmentInfo>>;
/**
* 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: (warehouseUid: number, request: ReplenishRequest) => Promise<boolean>;
/**
* 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: (warehouseUid: number, request: TransferRequest) => Promise<boolean>;
/**
* 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: (warehouseUid: number, request: UsageRequest) => Promise<boolean>;
/**
* 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: (warehouseUid: number, params: InventoryAvailabilityParams) => Promise<{
type: "prophet21" | "products";
description: string;
inv_mast_uid: number;
item_id: string;
qty_on_hand: number;
default_selling_unit: string;
}[]>;
/**
* 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: (warehouseUid: number, params?: ReplenishmentParams) => Promise<{
warehouse_uid: number;
replenishment_items: {
description: string;
inv_mast_uid: number;
item_id: string;
qty_on_hand: number;
min_qty: number;
max_qty: number;
reorder_qty: number;
suggested_order_qty: number;
distributor_uid: number;
}[];
}>;
};
/**
* Distributor management endpoints
* @description Methods for CRUD operations on distributors and supplier relationships
*/
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: (params?: {
edgeCache?: 3 | 2 | 4 | 1 | "1" | 5 | 8 | "2" | "3" | "4" | "5" | "8" | undefined;
limit?: number | undefined;
offset?: number | undefined;
customerId?: number | undefined;
statusCd?: number | undefined;
} | undefined) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
customer_id: number;
status_cd: number;
create_cd: string;
update_cd: string;
distributors_uid: number;
distributor_name: string;
distributor_desc?: string | undefined;
contact_email?: string | undefined;
contact_phone?: string | undefined;
}[];
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
total: number;
totalResults: number;
}>;
/**
* 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: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
customer_id: number;
status_cd: number;
create_cd: string;
update_cd: string;
distributors_uid: number;
distributor_name: string;
distributor_desc?: string | undefined;
contact_email?: string | undefined;
contact_phone?: string | undefined;
};
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
total: number;
totalResults: number;
}>;
/**
* 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: (data: {
customer_id: number;
distributor_name: string;
distributor_desc?: string | undefined;
contact_email?: string | undefined;
contact_phone?: string | undefined;
}) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
customer_id: number;
status_cd: number;
create_cd: string;
update_cd: string;
distributors_uid: number;
distributor_name: string;
distributor_desc?: string | undefined;
contact_email?: string | undefined;
contact_phone?: string | undefined;
};
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
total: number;
totalResults: number;
}>;
/**
* 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: (id: string | number, data: {
distributor_name?: string | undefined;
distributor_desc?: string | undefined;
contact_email?: string | undefined;
contact_phone?: string | undefined;
}) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
customer_id: number;
status_cd: number;
create_cd: string;
update_cd: string;
distributors_uid: number;
distributor_name: string;
distributor_desc?: string | undefined;
contact_email?: string | undefined;
contact_phone?: string | undefined;
};
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
total: number;
totalResults: number;
}>;
/**
* 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: (id: string | number) => Promise<boolean>;
/**
* 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: (distributorsUid: number, request: EnableDistributorRequest) => Promise<BaseResponse<Distributor>>;
/**
* 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: (params?: DistributorListParams) => Promise<{
customer_id: number;
status_cd: number;
create_cd: string;
update_cd: string;
distributors_uid: number;
distributor_name: string;
distributor_desc?: string | undefined;
contact_email?: string | undefined;
contact_phone?: string | undefined;
}[]>;
/**
* 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: (distributorsUid: number) => Promise<{
customer_id: number;
status_cd: number;
create_cd: string;
update_cd: string;
distributors_uid: number;
distributor_name: string;
distributor_desc?: string | undefined;
contact_email?: string | undefined;
contact_phone?: string | undefined;
}>;
/**
* 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: (request: CreateDistributorRequest) => Promise<{
customer_id: number;
status_cd: number;
create_cd: string;
update_cd: string;
distributors_uid: number;
distributor_name: string;
distributor_desc?: string | undefined;
contact_email?: string | undefined;
contact_phone?: string | undefined;
}>;
/**
* 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: (distributorsUid: number, request: UpdateDistributorRequest) => Promise<{
customer_id: number;
status_cd: number;
create_cd: string;
update_cd: string;
distributors_uid: number;
distributor_name: string;
distributor_desc?: string | undefined;
contact_email?: string | undefined;
contact_phone?: string | undefined;
}>;
/**
* 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: (distributorsUid: number, request: EnableDistributorRequest) => Promise<{
customer_id: number;
status_cd: number;
create_cd: string;
update_cd: string;
distributors_uid: number;
distributor_name: string;
distributor_desc?: string | undefined;
contact_email?: string | undefined;
contact_phone?: string | undefined;
}>;
};
/**
* Product management endpoints
* @description Methods for CRUD operations on products and product search functionality
*/
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: (params?: {
edgeCache?: 3 | 2 | 4 | 1 | "1" | 5 | 8 | "2" | "3" | "4" | "5" | "8" | undefined;
limit?: number | undefined;
offset?: number | undefined;
q?: string | undefined;
customerId?: number | undefined;
statusCd?: number | undefined;
distributorsUid?: number | undefined;
prefix?: string | undefined;
} | undefined) => Promise<{
params: Record<string, unknown> | unknown[];
data: {
customer_id: number;
status_cd: number;
create_cd: string;
update_cd: string;
distributors_uid: number;
products_uid: number;
product_id: string;
product_name: string;
product_desc?: string | undefined;
}[];
options: Record<string, unknown> | unknown[];
status: number;
message: string;
count: number;
total: number;
totalResults: number;
}>;
/**
* 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: (params: ProductFindParams) => Promise<BaseResponse<ProductFindItem[]>