@simpleapps-com/augur-api 0.1.0

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

@@ -0,0 +1,1376 @@
+import { BaseServiceClient } from '../../core/base-client';
+import type { HTTPClient } from '../../core/client';
+import type { StandardResponse } from '../../core/base-client';
+import { Warehouse, EnableWarehouseRequest, InventoryAvailability, InventoryAvailabilityParams, InventoryAdjustRequest, InventoryReceiveRequest, ReplenishmentInfo, ReplenishmentParams, ReplenishRequest, TransferRequest, UsageRequest, Distributor, EnableDistributorRequest, Product, ProductFindItem, ProductFindParams, CreateProductRequest, EnableProductRequest, InvProfileLine, InvProfileLineListParams, CreateInvProfileLineRequest, UpdateInvProfileLineRequest, Section, 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<{
+            data: "pong";
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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<{
+            data: {
+                siteHash: string;
+                siteId: string;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+    };
+    /**
+     * 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 | 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<{
+            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;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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<{
+            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;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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<{
+            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;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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<{
+            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;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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<StandardResponse<Warehouse>>;
+    };
+    /**
+     * 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<StandardResponse<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<StandardResponse<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>;
+    };
+    /**
+     * 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?: {
+            customerId: number;
+            edgeCache?: 3 | 2 | 4 | 1 | 5 | 8 | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+            statusCd?: number | undefined;
+        } | undefined) => Promise<{
+            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;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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<{
+            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;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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<{
+            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;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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<{
+            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;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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<StandardResponse<Distributor>>;
+    };
+    /**
+     * 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?: {
+            customerId: number;
+            distributorsUid: number;
+            edgeCache?: 3 | 2 | 4 | 1 | 5 | 8 | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+            q?: string | undefined;
+            statusCd?: number | undefined;
+            prefix?: string | undefined;
+        } | undefined) => Promise<{
+            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;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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<StandardResponse<ProductFindItem[]>>;
+        /**
+         * 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: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+            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;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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: (id: string | number, data: {
+            product_name?: string | undefined;
+            product_desc?: string | undefined;
+        }) => Promise<{
+            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;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * 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: (id: string | number) => Promise<boolean>;
+        /**
+         * 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: (productsUid: number, request: EnableProductRequest) => Promise<StandardResponse<Product>>;
+        /**
+         * 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: (distributorsUid: number, request: CreateProductRequest) => Promise<StandardResponse<Product>>;
+    };
+    /**
+     * Inventory Profile management endpoints
+     * @description Methods for managing inventory profiles that define min/max/reorder quantities for automated replenishment
+     */
+    inventoryProfiles: {
+        /**
+         * Inventory profile headers sub-endpoints
+         * @description Methods for managing inventory profile headers (containers for profile lines)
+         */
+        headers: {
+            /**
+             * List inventory profile headers
+             * @description Returns inventory profile headers for a customer with pagination
+             * @param params Filtering and pagination parameters (customerId is required)
+             * @returns Array of inventory profile header objects
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const headers = await client.inventoryProfiles.headers.list({ customerId: 12345 });
+             * headers.forEach(header => {
+             *   console.log(`${header.inv_profile_hdr_desc} (ID: ${header.inv_profile_hdr_uid})`);
+             * });
+             * ```
+             */
+            list: (params?: {
+                customerId: number;
+                edgeCache?: 3 | 2 | 4 | 1 | 5 | 8 | undefined;
+                limit?: number | undefined;
+                offset?: number | undefined;
+            } | undefined) => Promise<{
+                data: {
+                    customer_id: number;
+                    status_cd: number;
+                    inv_profile_hdr_uid: number;
+                    create_cd: string;
+                    update_cd: string;
+                    inv_profile_hdr_desc: string;
+                }[];
+                status: number;
+                options?: Record<string, unknown>[] | undefined;
+                message?: string | undefined;
+                totalResults?: number | undefined;
+                count?: number | undefined;
+            }>;
+            /**
+             * Get inventory profile header details
+             * @description Returns detailed information for a specific inventory profile header
+             * @param invProfileHdrUid Inventory profile header unique identifier
+             * @returns Inventory profile header details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const header = await client.inventoryProfiles.headers.get(1);
+             * console.log(header.inv_profile_hdr_desc);
+             * ```
+             */
+            get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+                data: {
+                    customer_id: number;
+                    status_cd: number;
+                    inv_profile_hdr_uid: number;
+                    create_cd: string;
+                    update_cd: string;
+                    inv_profile_hdr_desc: string;
+                };
+                status: number;
+                options?: Record<string, unknown>[] | undefined;
+                message?: string | undefined;
+                totalResults?: number | undefined;
+                count?: number | undefined;
+            }>;
+            /**
+             * Create new inventory profile header
+             * @description Creates a new inventory profile header container
+             * @param request Inventory profile header creation data
+             * @returns Created inventory profile header information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const header = await client.inventoryProfiles.headers.create({
+             *   inv_profile_hdr_desc: 'Standard Office Setup Profile',
+             *   customer_id: 12345
+             * });
+             * ```
+             */
+            create: (data: {
+                customer_id: number;
+                inv_profile_hdr_desc: string;
+            }) => Promise<{
+                data: {
+                    customer_id: number;
+                    status_cd: number;
+                    inv_profile_hdr_uid: number;
+                    create_cd: string;
+                    update_cd: string;
+                    inv_profile_hdr_desc: string;
+                };
+                status: number;
+                options?: Record<string, unknown>[] | undefined;
+                message?: string | undefined;
+                totalResults?: number | undefined;
+                count?: number | undefined;
+            }>;
+            /**
+             * Update inventory profile header
+             * @description Updates inventory profile header information
+             * @param invProfileHdrUid Inventory profile header unique identifier
+             * @param request Inventory profile header update data
+             * @returns Updated inventory profile header information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.inventoryProfiles.headers.update(1, {
+             *   inv_profile_hdr_desc: 'Updated Profile Description'
+             * });
+             * ```
+             */
+            update: (id: string | number, data: {
+                inv_profile_hdr_desc?: string | undefined;
+            }) => Promise<{
+                data: {
+                    customer_id: number;
+                    status_cd: number;
+                    inv_profile_hdr_uid: number;
+                    create_cd: string;
+                    update_cd: string;
+                    inv_profile_hdr_desc: string;
+                };
+                status: number;
+                options?: Record<string, unknown>[] | undefined;
+                message?: string | undefined;
+                totalResults?: number | undefined;
+                count?: number | undefined;
+            }>;
+            /**
+             * Delete inventory profile header
+             * @description Removes inventory profile header and associated lines
+             * @param invProfileHdrUid Inventory profile header unique identifier
+             * @returns Boolean indicating successful deletion
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const deleted = await client.inventoryProfiles.headers.delete(1);
+             * ```
+             */
+            delete: (id: string | number) => Promise<boolean>;
+        };
+        /**
+         * Inventory profile lines sub-endpoints
+         * @description Methods for managing inventory profile lines (individual item configurations within headers)
+         */
+        lines: {
+            /**
+             * List inventory profile lines for a header
+             * @description Returns inventory profile lines within a specific header with pagination
+             * @param invProfileHdrUid Inventory profile header unique identifier
+             * @param params Optional pagination parameters
+             * @returns Array of inventory profile line objects
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const lines = await client.inventoryProfiles.lines.list(1, { limit: 20 });
+             * lines.forEach(line => {
+             *   console.log(`Item ${line.inv_mast_uid}: Min ${line.min_qty}, Max ${line.max_qty}`);
+             * });
+             * ```
+             */
+            list: (invProfileHdrUid: number, params?: InvProfileLineListParams) => Promise<StandardResponse<InvProfileLine[]>>;
+            /**
+             * Get specific inventory profile line
+             * @description Returns detailed information for a specific inventory profile line
+             * @param invProfileHdrUid Inventory profile header unique identifier
+             * @param invProfileLineUid Inventory profile line unique identifier
+             * @returns Inventory profile line details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const line = await client.inventoryProfiles.lines.get(1, 10);
+             * console.log(`${line.inv_profile_line_type}: ${line.min_qty}-${line.max_qty}`);
+             * ```
+             */
+            get: (invProfileHdrUid: number, invProfileLineUid: number) => Promise<StandardResponse<InvProfileLine>>;
+            /**
+             * Create inventory profile line
+             * @description Creates a new inventory profile line with min/max/reorder quantities
+             * @param invProfileHdrUid Inventory profile header unique identifier
+             * @param request Inventory profile line creation data
+             * @returns Created inventory profile line information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const line = await client.inventoryProfiles.lines.create(1, {
+             *   inv_mast_uid: 456,
+             *   inv_profile_line_type: 'prophet21',
+             *   min_qty: 50.0,
+             *   max_qty: 200.0,
+             *   reorder_qty: 100.0
+             * });
+             * ```
+             */
+            create: (invProfileHdrUid: number, request: CreateInvProfileLineRequest) => Promise<StandardResponse<InvProfileLine>>;
+            /**
+             * Update inventory profile line
+             * @description Updates inventory profile line quantities and settings
+             * @param invProfileHdrUid Inventory profile header unique identifier
+             * @param invProfileLineUid Inventory profile line unique identifier
+             * @param request Inventory profile line update data
+             * @returns Updated inventory profile line information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.inventoryProfiles.lines.update(1, 10, {
+             *   min_qty: 75.0,
+             *   max_qty: 250.0
+             * });
+             * ```
+             */
+            update: (invProfileHdrUid: number, invProfileLineUid: number, request: UpdateInvProfileLineRequest) => Promise<StandardResponse<InvProfileLine>>;
+            /**
+             * Delete inventory profile line
+             * @description Removes inventory profile line from header
+             * @param invProfileHdrUid Inventory profile header unique identifier
+             * @param invProfileLineUid Inventory profile line unique identifier
+             * @returns Boolean indicating successful deletion
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const deleted = await client.inventoryProfiles.lines.delete(1, 10);
+             * ```
+             */
+            delete: (invProfileHdrUid: number, invProfileLineUid: number) => Promise<boolean>;
+        };
+    };
+    /**
+     * Restocking management endpoints
+     * @description Methods for managing restock headers and replenishment operations
+     */
+    restocking: {
+        /**
+         * List restock headers with filtering
+         * @description Returns restock headers with optional filtering by warehouse and distributor
+         * @param params Optional filtering and pagination parameters
+         * @returns Array of restock header objects
+         * @throws ValidationError When parameters are invalid or response is malformed
+         * @example
+         * ```typescript
+         * const restockHeaders = await client.restocking.list({
+         *   warehouseUid: 123,
+         *   distributorsUid: 789
+         * });
+         * ```
+         */
+        list: (params?: {
+            edgeCache?: 3 | 2 | 4 | 1 | 5 | 8 | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+            distributorsUid?: number | undefined;
+            warehouseUid?: number | undefined;
+        } | undefined) => Promise<{
+            data: {
+                status_cd: number;
+                warehouse_uid: number;
+                create_cd: string;
+                update_cd: string;
+                distributors_uid: number;
+                restock_hdr_uid: number;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Get restock header details
+         * @description Returns detailed information for a specific restock header
+         * @param restockHdrUid Restock header unique identifier
+         * @returns Restock header details
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const header = await client.restocking.get(100);
+         * console.log(`Warehouse: ${header.warehouse_uid}, Distributor: ${header.distributors_uid}`);
+         * ```
+         */
+        get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+            data: {
+                status_cd: number;
+                warehouse_uid: number;
+                create_cd: string;
+                update_cd: string;
+                distributors_uid: number;
+                restock_hdr_uid: number;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Create restock header
+         * @description Creates a new restock header for warehouse and distributor combination
+         * @param request Restock header creation data
+         * @returns Created restock header information
+         * @throws ValidationError When request is invalid or response is malformed
+         * @example
+         * ```typescript
+         * const header = await client.restocking.create({
+         *   warehouse_uid: 123,
+         *   distributors_uid: 789
+         * });
+         * ```
+         */
+        create: (data: {
+            warehouse_uid: number;
+            distributors_uid: number;
+        }) => Promise<{
+            data: {
+                status_cd: number;
+                warehouse_uid: number;
+                create_cd: string;
+                update_cd: string;
+                distributors_uid: number;
+                restock_hdr_uid: number;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Update restock header
+         * @description Updates restock header configuration
+         * @param restockHdrUid Restock header unique identifier
+         * @param request Restock header update data
+         * @returns Updated restock header information
+         * @throws ValidationError When request is invalid or response is malformed
+         * @example
+         * ```typescript
+         * const updated = await client.restocking.update(100, {
+         *   warehouse_uid: 124
+         * });
+         * ```
+         */
+        update: (id: string | number, data: {
+            warehouse_uid?: number | undefined;
+            distributors_uid?: number | undefined;
+        }) => Promise<{
+            data: {
+                status_cd: number;
+                warehouse_uid: number;
+                create_cd: string;
+                update_cd: string;
+                distributors_uid: number;
+                restock_hdr_uid: number;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Delete restock header
+         * @description Removes restock header and associated data
+         * @param restockHdrUid Restock header unique identifier
+         * @returns Boolean indicating successful deletion
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const deleted = await client.restocking.delete(100);
+         * ```
+         */
+        delete: (id: string | number) => Promise<boolean>;
+    };
+    /**
+     * Sections management endpoints
+     * @description Methods for managing warehouse organizational sections
+     */
+    sections: {
+        /**
+         * List sections with filtering
+         * @description Returns sections for a customer with optional status filtering and pagination
+         * @param params Filtering and pagination parameters (customerId is required)
+         * @returns Array of section objects
+         * @throws ValidationError When parameters are invalid or response is malformed
+         * @example
+         * ```typescript
+         * const sections = await client.sections.list({ customerId: 12345 });
+         * sections.forEach(section => {
+         *   console.log(`${section.section_name}: ${section.section_desc}`);
+         * });
+         * ```
+         */
+        list: (params?: {
+            customerId: number;
+            edgeCache?: 3 | 2 | 4 | 1 | 5 | 8 | undefined;
+            limit?: number | undefined;
+            offset?: number | undefined;
+            statusCd?: number | undefined;
+        } | undefined) => Promise<{
+            data: {
+                customer_id: number;
+                status_cd: number;
+                create_cd: string;
+                update_cd: string;
+                sections_uid: number;
+                section_name: string;
+                section_desc?: string | undefined;
+            }[];
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Get section details by ID
+         * @description Returns detailed information for a specific section
+         * @param sectionsUid Section unique identifier
+         * @returns Section details
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const section = await client.sections.get(200);
+         * console.log(section.section_name, section.section_desc);
+         * ```
+         */
+        get: (id: string | number, params?: import("../../core/base-client").CacheParams | undefined) => Promise<{
+            data: {
+                customer_id: number;
+                status_cd: number;
+                create_cd: string;
+                update_cd: string;
+                sections_uid: number;
+                section_name: string;
+                section_desc?: string | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Create new section
+         * @description Creates a new organizational section for a customer
+         * @param request Section creation data
+         * @returns Created section information
+         * @throws ValidationError When request is invalid or response is malformed
+         * @example
+         * ```typescript
+         * const section = await client.sections.create({
+         *   section_name: 'Electronics Section',
+         *   section_desc: 'Electronic components and devices',
+         *   customer_id: 12345
+         * });
+         * ```
+         */
+        create: (data: {
+            customer_id: number;
+            section_name: string;
+            section_desc?: string | undefined;
+        }) => Promise<{
+            data: {
+                customer_id: number;
+                status_cd: number;
+                create_cd: string;
+                update_cd: string;
+                sections_uid: number;
+                section_name: string;
+                section_desc?: string | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Update section information
+         * @description Updates section details with provided data
+         * @param sectionsUid Section unique identifier
+         * @param request Section update data
+         * @returns Updated section information
+         * @throws ValidationError When request is invalid or response is malformed
+         * @example
+         * ```typescript
+         * const updated = await client.sections.update(200, {
+         *   section_name: 'Updated Section Name',
+         *   section_desc: 'Updated description'
+         * });
+         * ```
+         */
+        update: (id: string | number, data: {
+            section_name?: string | undefined;
+            section_desc?: string | undefined;
+        }) => Promise<{
+            data: {
+                customer_id: number;
+                status_cd: number;
+                create_cd: string;
+                update_cd: string;
+                sections_uid: number;
+                section_name: string;
+                section_desc?: string | undefined;
+            };
+            status: number;
+            options?: Record<string, unknown>[] | undefined;
+            message?: string | undefined;
+            totalResults?: number | undefined;
+            count?: number | undefined;
+        }>;
+        /**
+         * Soft delete a section
+         * @description Marks section as deleted without removing data
+         * @param sectionsUid Section unique identifier
+         * @returns Boolean indicating successful deletion
+         * @throws ValidationError When response is malformed
+         * @example
+         * ```typescript
+         * const deleted = await client.sections.delete(200);
+         * ```
+         */
+        delete: (id: string | number) => Promise<boolean>;
+        /**
+         * Enable, disable, or delete a section
+         * @description Changes section status using status codes
+         * @param sectionsUid Section unique identifier
+         * @param request Status change request with new status code
+         * @returns Updated section information
+         * @throws ValidationError When request is invalid or response is malformed
+         * @example
+         * ```typescript
+         * await client.sections.enable(200, { status_cd: 705 }); // Disable
+         * await client.sections.enable(200, { status_cd: 704 }); // Enable
+         * ```
+         */
+        enable: (sectionsUid: number, request: EnableSectionRequest) => Promise<StandardResponse<Section>>;
+    };
+    /**
+     * User access management endpoints
+     * @description Methods for managing user access permissions to warehouses
+     */
+    userAccess: {
+        /**
+         * List users with access to specific warehouse
+         * @description Returns users who have access to a warehouse with optional status filtering
+         * @param warehouseUid Warehouse unique identifier
+         * @param params Optional filtering and pagination parameters
+         * @returns Array of warehouse user access records
+         * @throws ValidationError When parameters are invalid or response is malformed
+         * @example
+         * ```typescript
+         * const users = await client.userAccess.listWarehouseUsers(123, { limit: 20 });
+         * users.forEach(user => {
+         *   console.log(`User ${user.users_id} - Status: ${user.status_cd}`);
+         * });
+         * ```
+         */
+        listWarehouseUsers: (warehouseUid: number, params?: WarehouseUserListParams) => Promise<StandardResponse<unknown[]>>;
+        /**
+         * Create or update warehouse user access
+         * @description Grants or updates user access to a warehouse with optional primary user designation
+         * @param warehouseUid Warehouse unique identifier
+         * @param request User access request data
+         * @returns Created or updated warehouse user access information
+         * @throws ValidationError When request is invalid or response is malformed
+         * @example
+         * ```typescript
+         * // Grant standard access
+         * const access = await client.userAccess.createWarehouseUser(123, {
+         *   users_id: 456,
+         *   status_cd: 704
+         * });
+         *
+         * // Grant access
+         * const access2 = await client.userAccess.createWarehouseUser(123, {
+         *   users_id: 456,
+         *   status_cd: 704
+         * });
+         * ```
+         */
+        createWarehouseUser: (warehouseUid: number, request: CreateWarehouseUserRequest) => Promise<unknown>;
+    };
+}
+//# sourceMappingURL=client.d.ts.map