@simpleapps-com/augur-api 0.1.0

package/dist/cjs/services/vmi/client.js

@@ -0,0 +1,1072 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VMIClient = void 0;
+const base_client_1 = require("../../core/base-client");
+const zod_1 = require("zod");
+const schemas_1 = require("./schemas");
+/**
+ * VMI (Vendor Managed Inventory) API Client
+ * @description Client for interacting with VMI microservice API endpoints for warehouse and inventory management
+ * @example
+ * ```typescript
+ * import { HTTPClient } from '@augur/api-client/core';
+ * import { VMIClient } from '@augur/api-client/services/vmi';
+ *
+ * const http = new HTTPClient('vmi', { siteId: 'your-site-id', bearerToken: 'your-token' });
+ * const vmi = new VMIClient(http);
+ *
+ * // List warehouses
+ * const warehouses = await vmi.warehouses.list({ customerId: 12345 });
+ *
+ * // Check inventory availability
+ * const inventory = await vmi.inventory.checkAvailability(123, { q: 'wire' });
+ * ```
+ */
+class VMIClient extends base_client_1.BaseServiceClient {
+    /**
+     * Create a new VMIClient instance
+     * @param http Configured HTTPClient instance
+     * @param baseUrl Base URL for the VMI API (default: https://vmi.augur-api.com)
+     */
+    constructor(http, baseUrl = 'https://vmi.augur-api.com') {
+        super('vmi', http, baseUrl);
+        /**
+         * Health monitoring endpoints
+         * @description Methods for checking service availability and health status
+         */
+        this.health = {
+            /**
+             * Simple health check endpoint that doesn't require authentication
+             * @description Returns "pong" response for basic connectivity testing
+             * @returns Simple pong response
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const pong = await client.health.ping();
+             * console.log(pong.data); // "pong"
+             * ```
+             */
+            ping: this.createPingMethod(schemas_1.PingResponseSchema),
+            /**
+             * Comprehensive health check with authentication and site validation
+             * @description Validates authentication, site configuration, and triggers seed site jobs
+             * @returns Health check response with site information
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const health = await client.health.check();
+             * console.log('Site:', health.data.siteId, 'Hash:', health.data.siteHash);
+             * ```
+             */
+            check: this.createHealthCheckMethod(schemas_1.HealthCheckResponseSchema),
+        };
+        /**
+         * Warehouse management endpoints
+         * @description Methods for CRUD operations on warehouses and warehouse configuration
+         */
+        this.warehouses = {
+            /**
+             * List warehouses with filtering and pagination
+             * @description Returns warehouses with optional filtering by customer, user access, and status
+             * @param params Optional filtering and pagination parameters
+             * @returns Array of warehouse objects with pagination metadata
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * // List all warehouses for a customer
+             * const warehouses = await client.warehouses.list({ customerId: 12345 });
+             *
+             * // Search warehouses with pagination
+             * const results = await client.warehouses.list({
+             *   customerId: 12345,
+             *   q: 'distribution',
+             *   limit: 5,
+             *   offset: 0
+             * });
+             *
+             * // Filter by user access
+             * const userWarehouses = await client.warehouses.list({
+             *   customerId: 12345,
+             *   usersId: 456
+             * });
+             * ```
+             */
+            list: this.createListMethod('/warehouse', schemas_1.WarehouseListParamsSchema, schemas_1.WarehouseListResponseSchema),
+            /**
+             * Get warehouse details by ID
+             * @description Returns detailed information for a specific warehouse
+             * @param warehouseUid Warehouse unique identifier
+             * @returns Warehouse details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const warehouse = await client.warehouses.get(123);
+             * console.log(warehouse.warehouse_name, warehouse.status_cd);
+             * ```
+             */
+            get: this.createGetMethod('/warehouse/{id}', schemas_1.WarehouseResponseSchema),
+            /**
+             * Create a new warehouse
+             * @description Creates a new warehouse with specified configuration
+             * @param request Warehouse creation data
+             * @returns Created warehouse information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const newWarehouse = await client.warehouses.create({
+             *   warehouse_name: 'West Coast Distribution',
+             *   warehouse_desc: 'Primary warehouse for west coast operations',
+             *   customer_id: 12345,
+             *   inv_profile_hdr_uid: 1
+             * });
+             * ```
+             */
+            create: this.createCreateMethod('/warehouse', schemas_1.CreateWarehouseRequestSchema, schemas_1.WarehouseResponseSchema),
+            /**
+             * Update an existing warehouse
+             * @description Updates warehouse information with provided data
+             * @param warehouseUid Warehouse unique identifier
+             * @param request Warehouse update data
+             * @returns Updated warehouse information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.warehouses.update(123, {
+             *   warehouse_name: 'Updated Warehouse Name',
+             *   warehouse_desc: 'Updated description'
+             * });
+             * ```
+             */
+            update: this.createUpdateMethod('/warehouse/{id}', schemas_1.UpdateWarehouseRequestSchema, schemas_1.WarehouseResponseSchema),
+            /**
+             * Soft delete a warehouse
+             * @description Marks warehouse as deleted (sets status_cd to 700) without removing data
+             * @param warehouseUid Warehouse unique identifier
+             * @returns Boolean indicating successful deletion
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const deleted = await client.warehouses.delete(123);
+             * ```
+             */
+            delete: this.createDeleteBooleanMethod('/warehouse/{id}'),
+            /**
+             * Enable, disable, or delete a warehouse
+             * @description Changes warehouse status using status codes (704=active, 705=inactive, 700=deleted)
+             * @param warehouseUid Warehouse unique identifier
+             * @param request Status change request with new status code
+             * @returns Updated warehouse information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * // Disable warehouse
+             * await client.warehouses.enable(123, { status_cd: 705 });
+             *
+             * // Re-enable warehouse
+             * await client.warehouses.enable(123, { status_cd: 704 });
+             *
+             * // Delete warehouse
+             * await client.warehouses.enable(123, { status_cd: 700 });
+             * ```
+             */
+            enable: async (warehouseUid, request) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/warehouse/{id}/enable',
+                    paramsSchema: schemas_1.EnableWarehouseRequestSchema,
+                    responseSchema: schemas_1.WarehouseResponseSchema,
+                }, request, { id: String(warehouseUid) });
+            },
+        };
+        /**
+         * Inventory operation endpoints
+         * @description Methods for inventory management including availability, adjustments, receiving, and usage tracking
+         */
+        this.inventory = {
+            /**
+             * Check inventory availability with search
+             * @description Searches inventory items in a warehouse with query string matching
+             * @param warehouseUid Warehouse unique identifier
+             * @param params Search parameters including required query string
+             * @returns Array of available inventory items matching search criteria
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const items = await client.inventory.checkAvailability(123, { q: 'wire' });
+             * items.forEach(item => {
+             *   console.log(`${item.item_id}: ${item.qty_on_hand} ${item.default_selling_unit}`);
+             * });
+             * ```
+             */
+            checkAvailability: async (warehouseUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/warehouse/{id}/availability',
+                    paramsSchema: schemas_1.InventoryAvailabilityParamsSchema,
+                    responseSchema: schemas_1.InventoryAvailabilityResponseSchema,
+                }, params, { id: String(warehouseUid) });
+            },
+            /**
+             * Adjust inventory quantities
+             * @description Sets absolute inventory quantities (not relative changes) with optional reason tracking
+             * @param warehouseUid Warehouse unique identifier
+             * @param request Adjustment request containing array of inventory adjustments
+             * @returns Success response
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * await client.inventory.adjust(123, {
+             *   adjustments: [
+             *     {
+             *       inv_mast_uid: 456,
+             *       qty_on_hand: 200.0,
+             *       reason: 'Physical count adjustment'
+             *     },
+             *     {
+             *       inv_mast_uid: 789,
+             *       qty_on_hand: 150.0,
+             *       reason: 'Damage correction'
+             *     }
+             *   ]
+             * });
+             * ```
+             */
+            adjust: async (warehouseUid, request) => {
+                await this.executeRequest({
+                    method: 'POST',
+                    path: '/warehouse/{id}/adjust',
+                    paramsSchema: schemas_1.InventoryAdjustRequestSchema,
+                    responseSchema: zod_1.z.boolean(),
+                }, request, { id: String(warehouseUid) });
+                return true;
+            },
+            /**
+             * Receive inventory into warehouse
+             * @description Records received inventory with optional purchase order and lot tracking
+             * @param warehouseUid Warehouse unique identifier
+             * @param request Receive request containing array of inventory receipts
+             * @returns Success response
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * await client.inventory.receive(123, {
+             *   receipts: [
+             *     {
+             *       inv_mast_uid: 456,
+             *       qty_received: 50.0,
+             *       po_number: 'PO-2024-001',
+             *       lot_number: 'LOT-456'
+             *     }
+             *   ]
+             * });
+             * ```
+             */
+            receive: async (warehouseUid, request) => {
+                await this.executeRequest({
+                    method: 'POST',
+                    path: '/warehouse/{id}/receive',
+                    paramsSchema: schemas_1.InventoryReceiveRequestSchema,
+                    responseSchema: zod_1.z.boolean(),
+                }, request, { id: String(warehouseUid) });
+                return true;
+            },
+            /**
+             * Get replenishment information
+             * @description Returns items that need replenishment based on min/max quantities
+             * @param warehouseUid Warehouse unique identifier
+             * @param params Optional filtering by distributor
+             * @returns Replenishment information with suggested order quantities
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const replenishment = await client.inventory.getReplenishmentInfo(123, { distributorsUid: 789 });
+             * replenishment.replenishment_items.forEach(item => {
+             *   console.log(`${item.item_id}: Need ${item.suggested_order_qty} (current: ${item.qty_on_hand})`);
+             * });
+             * ```
+             */
+            getReplenishmentInfo: async (warehouseUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/warehouse/{id}/replenish',
+                    paramsSchema: schemas_1.ReplenishmentParamsSchema,
+                    responseSchema: schemas_1.ReplenishmentInfoResponseSchema,
+                }, params, { id: String(warehouseUid) });
+            },
+            /**
+             * Execute inventory replenishment
+             * @description Places replenishment orders based on min/max/reorder quantities
+             * @param warehouseUid Warehouse unique identifier
+             * @param request Replenishment request with distributor and items to restock
+             * @returns Success response
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * await client.inventory.replenish(123, {
+             *   distributor_uid: 789,
+             *   restock_items: [
+             *     { inv_mast_uid: 456, qty_to_order: 100.0 },
+             *     { inv_mast_uid: 789, qty_to_order: 75.0 }
+             *   ]
+             * });
+             * ```
+             */
+            replenish: async (warehouseUid, request) => {
+                await this.executeRequest({
+                    method: 'POST',
+                    path: '/warehouse/{id}/replenish',
+                    paramsSchema: schemas_1.ReplenishRequestSchema,
+                    responseSchema: zod_1.z.boolean(),
+                }, request, { id: String(warehouseUid) });
+                return true;
+            },
+            /**
+             * Transfer inventory between warehouses
+             * @description Moves inventory from one warehouse to another with quantity tracking
+             * @param warehouseUid Source warehouse unique identifier
+             * @param request Transfer request with destination warehouse and items to transfer
+             * @returns Success response
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * await client.inventory.transfer(123, {
+             *   to_warehouse_uid: 124,
+             *   transfers: [
+             *     {
+             *       inv_mast_uid: 456,
+             *       qty_to_transfer: 25.0,
+             *       reason: 'Stock balancing'
+             *     }
+             *   ]
+             * });
+             * ```
+             */
+            transfer: async (warehouseUid, request) => {
+                await this.executeRequest({
+                    method: 'POST',
+                    path: '/warehouse/{id}/transfer',
+                    paramsSchema: schemas_1.TransferRequestSchema,
+                    responseSchema: zod_1.z.boolean(),
+                }, request, { id: String(warehouseUid) });
+                return true;
+            },
+            /**
+             * Record inventory usage
+             * @description Automatically decrements inventory and creates usage records for job tracking
+             * @param warehouseUid Warehouse unique identifier
+             * @param request Usage request with job information and consumed items
+             * @returns Success response
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * await client.inventory.recordUsage(123, {
+             *   job_description: 'Office Renovation - Building A',
+             *   department: 'Facilities',
+             *   usage_items: [
+             *     {
+             *       inv_mast_uid: 456,
+             *       inv_profile_line_type: 'prophet21',
+             *       qty_used: 5.0
+             *     },
+             *     {
+             *       inv_mast_uid: 789,
+             *       inv_profile_line_type: 'products',
+             *       qty_used: 2.0,
+             *       warranty: {
+             *         model_no: 'MDL-123',
+             *         serial_no: 'SN-456789',
+             *         warranty_type: 'Standard',
+             *         notes: 'Installed in conference room'
+             *       }
+             *     }
+             *   ]
+             * });
+             * ```
+             */
+            recordUsage: async (warehouseUid, request) => {
+                await this.executeRequest({
+                    method: 'POST',
+                    path: '/warehouse/{id}/usage',
+                    paramsSchema: schemas_1.UsageRequestSchema,
+                    responseSchema: zod_1.z.boolean(),
+                }, request, { id: String(warehouseUid) });
+                return true;
+            },
+        };
+        /**
+         * Distributor management endpoints
+         * @description Methods for CRUD operations on distributors and supplier relationships
+         */
+        this.distributors = {
+            /**
+             * List distributors with filtering
+             * @description Returns distributors for a customer with optional status filtering and pagination
+             * @param params Filtering and pagination parameters (customerId is required)
+             * @returns Array of distributor objects
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const distributors = await client.distributors.list({ customerId: 12345 });
+             * distributors.forEach(dist => {
+             *   console.log(`${dist.distributor_name}: ${dist.contact_email}`);
+             * });
+             * ```
+             */
+            list: this.createListMethod('/distributors', schemas_1.DistributorListParamsSchema, schemas_1.DistributorListResponseSchema),
+            /**
+             * Get distributor details by ID
+             * @description Returns detailed information for a specific distributor
+             * @param distributorsUid Distributor unique identifier
+             * @returns Distributor details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const distributor = await client.distributors.get(789);
+             * console.log(distributor.distributor_name, distributor.contact_email);
+             * ```
+             */
+            get: this.createGetMethod('/distributors/{id}', schemas_1.DistributorResponseSchema),
+            /**
+             * Create a new distributor
+             * @description Creates a new distributor with contact information
+             * @param request Distributor creation data
+             * @returns Created distributor information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const distributor = await client.distributors.create({
+             *   distributor_name: 'ABC Supply Co',
+             *   distributor_desc: 'Primary electrical supplier',
+             *   customer_id: 12345,
+             *   contact_email: 'orders@abcsupply.com',
+             *   contact_phone: '555-1234'
+             * });
+             * ```
+             */
+            create: this.createCreateMethod('/distributors', schemas_1.CreateDistributorRequestSchema, schemas_1.DistributorResponseSchema),
+            /**
+             * Update distributor information
+             * @description Updates distributor details with provided data
+             * @param distributorsUid Distributor unique identifier
+             * @param request Distributor update data
+             * @returns Updated distributor information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.distributors.update(789, {
+             *   contact_email: 'newemail@abcsupply.com',
+             *   contact_phone: '555-9999'
+             * });
+             * ```
+             */
+            update: this.createUpdateMethod('/distributors/{id}', schemas_1.UpdateDistributorRequestSchema, schemas_1.DistributorResponseSchema),
+            /**
+             * Soft delete a distributor
+             * @description Marks distributor as deleted without removing data
+             * @param distributorsUid Distributor unique identifier
+             * @returns Boolean indicating successful deletion
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const deleted = await client.distributors.delete(789);
+             * ```
+             */
+            delete: this.createDeleteBooleanMethod('/distributors/{id}'),
+            /**
+             * Enable, disable, or delete a distributor
+             * @description Changes distributor status using status codes
+             * @param distributorsUid Distributor unique identifier
+             * @param request Status change request with new status code
+             * @returns Updated distributor information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * await client.distributors.enable(789, { status_cd: 705 }); // Disable
+             * await client.distributors.enable(789, { status_cd: 704 }); // Enable
+             * ```
+             */
+            enable: async (distributorsUid, request) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/distributors/{id}/enable',
+                    paramsSchema: schemas_1.EnableDistributorRequestSchema,
+                    responseSchema: schemas_1.DistributorResponseSchema,
+                }, request, { id: String(distributorsUid) });
+            },
+        };
+        /**
+         * Product management endpoints
+         * @description Methods for CRUD operations on products and product search functionality
+         */
+        this.products = {
+            /**
+             * List products with filtering
+             * @description Returns products for a customer and distributor with optional filtering and pagination
+             * @param params Filtering and pagination parameters (customerId and distributorsUid are required)
+             * @returns Array of product objects
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const products = await client.products.list({
+             *   customerId: 12345,
+             *   distributorsUid: 789,
+             *   prefix: 'WIRE',
+             *   limit: 20
+             * });
+             * ```
+             */
+            list: this.createListMethod('/products', schemas_1.ProductListParamsSchema, schemas_1.ProductListResponseSchema),
+            /**
+             * Search across both VMI products and Prophet 21 items
+             * @description Searches both VMI custom products and Prophet 21 items with prefix matching
+             * @param params Search parameters with customer ID and optional prefix filter
+             * @returns Array of found items with type indicator (limited to 10 results)
+             * @throws ValidationError When parameters are invalid or response is malformed
+             * @example
+             * ```typescript
+             * const items = await client.products.find({
+             *   customerId: 12345,
+             *   prefix: 'WIRE'
+             * });
+             *
+             * items.forEach(item => {
+             *   console.log(`${item.item_id} (${item.type}): ${item.description}`);
+             * });
+             * ```
+             */
+            find: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/products/find',
+                    paramsSchema: schemas_1.ProductFindParamsSchema,
+                    responseSchema: schemas_1.ProductFindResponseSchema,
+                }, params);
+            },
+            /**
+             * Get product details by ID
+             * @description Returns detailed information for a specific product
+             * @param productsUid Product unique identifier
+             * @returns Product details
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const product = await client.products.get(456);
+             * console.log(product.product_name, product.product_desc);
+             * ```
+             */
+            get: this.createGetMethod('/products/{id}', schemas_1.ProductResponseSchema),
+            /**
+             * Update product information
+             * @description Updates product details with provided data
+             * @param productsUid Product unique identifier
+             * @param request Product update data
+             * @returns Updated product information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const updated = await client.products.update(456, {
+             *   product_name: 'Updated Product Name',
+             *   product_desc: 'Updated description'
+             * });
+             * ```
+             */
+            update: this.createUpdateMethod('/products/{id}', schemas_1.UpdateProductRequestSchema, schemas_1.ProductResponseSchema),
+            /**
+             * Soft delete a product
+             * @description Marks product as deleted without removing data
+             * @param productsUid Product unique identifier
+             * @returns Boolean indicating successful deletion
+             * @throws ValidationError When response is malformed
+             * @example
+             * ```typescript
+             * const deleted = await client.products.delete(456);
+             * ```
+             */
+            delete: this.createDeleteBooleanMethod('/products/{id}'),
+            /**
+             * Enable, disable, or delete a product
+             * @description Changes product status using status codes
+             * @param productsUid Product unique identifier
+             * @param request Status change request with new status code
+             * @returns Updated product information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * await client.products.enable(456, { status_cd: 705 }); // Disable
+             * await client.products.enable(456, { status_cd: 704 }); // Enable
+             * ```
+             */
+            enable: async (productsUid, request) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/products/{id}/enable',
+                    paramsSchema: schemas_1.EnableProductRequestSchema,
+                    responseSchema: schemas_1.ProductResponseSchema,
+                }, request, { id: String(productsUid) });
+            },
+            /**
+             * Create product associated with distributor
+             * @description Creates a new product and associates it with a distributor
+             * @param distributorsUid Distributor unique identifier
+             * @param request Product creation data
+             * @returns Created product information
+             * @throws ValidationError When request is invalid or response is malformed
+             * @example
+             * ```typescript
+             * const product = await client.products.createForDistributor(789, {
+             *   product_id: 'PROD-001',
+             *   product_name: 'New Product',
+             *   product_desc: 'Product description',
+             *   distributors_uid: 789,
+             *   customer_id: 12345
+             * });
+             * ```
+             */
+            createForDistributor: async (distributorsUid, request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/distributors/{id}/products',
+                    paramsSchema: schemas_1.CreateProductRequestSchema,
+                    responseSchema: schemas_1.ProductResponseSchema,
+                }, request, { id: String(distributorsUid) });
+            },
+        };
+        /**
+         * Inventory Profile management endpoints
+         * @description Methods for managing inventory profiles that define min/max/reorder quantities for automated replenishment
+         */
+        this.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: this.createListMethod('/inv-profile-hdr', schemas_1.InvProfileHdrListParamsSchema, schemas_1.InvProfileHdrListResponseSchema),
+                /**
+                 * 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: this.createGetMethod('/inv-profile-hdr/{id}', schemas_1.InvProfileHdrResponseSchema),
+                /**
+                 * 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: this.createCreateMethod('/inv-profile-hdr', schemas_1.CreateInvProfileHdrRequestSchema, schemas_1.InvProfileHdrResponseSchema),
+                /**
+                 * 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: this.createUpdateMethod('/inv-profile-hdr/{id}', schemas_1.UpdateInvProfileHdrRequestSchema, schemas_1.InvProfileHdrResponseSchema),
+                /**
+                 * 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: this.createDeleteBooleanMethod('/inv-profile-hdr/{id}'),
+            },
+            /**
+             * 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: async (invProfileHdrUid, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-profile-hdr/{id}/inv-profile-line',
+                        paramsSchema: schemas_1.InvProfileLineListParamsSchema,
+                        responseSchema: schemas_1.InvProfileLineListResponseSchema,
+                    }, params, { id: String(invProfileHdrUid) });
+                },
+                /**
+                 * 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: async (invProfileHdrUid, invProfileLineUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-profile-hdr/{hdrId}/inv-profile-line/{lineId}',
+                        responseSchema: schemas_1.InvProfileLineResponseSchema,
+                    }, undefined, { hdrId: String(invProfileHdrUid), lineId: String(invProfileLineUid) });
+                },
+                /**
+                 * 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: async (invProfileHdrUid, request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/inv-profile-hdr/{id}/inv-profile-line',
+                        paramsSchema: schemas_1.CreateInvProfileLineRequestSchema,
+                        responseSchema: schemas_1.InvProfileLineResponseSchema,
+                    }, request, { id: String(invProfileHdrUid) });
+                },
+                /**
+                 * 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: async (invProfileHdrUid, invProfileLineUid, request) => {
+                    return this.executeRequest({
+                        method: 'PUT',
+                        path: '/inv-profile-hdr/{hdrId}/inv-profile-line/{lineId}',
+                        paramsSchema: schemas_1.UpdateInvProfileLineRequestSchema,
+                        responseSchema: schemas_1.InvProfileLineResponseSchema,
+                    }, request, { hdrId: String(invProfileHdrUid), lineId: String(invProfileLineUid) });
+                },
+                /**
+                 * 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: async (invProfileHdrUid, invProfileLineUid) => {
+                    await this.executeRequest({
+                        method: 'DELETE',
+                        path: '/inv-profile-hdr/{hdrId}/inv-profile-line/{lineId}',
+                        responseSchema: zod_1.z.any(),
+                    }, undefined, { hdrId: String(invProfileHdrUid), lineId: String(invProfileLineUid) });
+                    return true;
+                },
+            },
+        };
+        /**
+         * Restocking management endpoints
+         * @description Methods for managing restock headers and replenishment operations
+         */
+        this.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: this.createListMethod('/restock-hdr', schemas_1.RestockHdrListParamsSchema, schemas_1.RestockHdrListResponseSchema),
+            /**
+             * 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: this.createGetMethod('/restock-hdr/{id}', schemas_1.RestockHdrResponseSchema),
+            /**
+             * 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: this.createCreateMethod('/restock-hdr', schemas_1.CreateRestockHdrRequestSchema, schemas_1.RestockHdrResponseSchema),
+            /**
+             * 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: this.createUpdateMethod('/restock-hdr/{id}', schemas_1.UpdateRestockHdrRequestSchema, schemas_1.RestockHdrResponseSchema),
+            /**
+             * 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: this.createDeleteBooleanMethod('/restock-hdr/{id}'),
+        };
+        /**
+         * Sections management endpoints
+         * @description Methods for managing warehouse organizational sections
+         */
+        this.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: this.createListMethod('/sections', schemas_1.SectionListParamsSchema, schemas_1.SectionListResponseSchema),
+            /**
+             * 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: this.createGetMethod('/sections/{id}', schemas_1.SectionResponseSchema),
+            /**
+             * 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: this.createCreateMethod('/sections', schemas_1.CreateSectionRequestSchema, schemas_1.SectionResponseSchema),
+            /**
+             * 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: this.createUpdateMethod('/sections/{id}', schemas_1.UpdateSectionRequestSchema, schemas_1.SectionResponseSchema),
+            /**
+             * 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: this.createDeleteBooleanMethod('/sections/{id}'),
+            /**
+             * 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: async (sectionsUid, request) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/sections/{id}/enable',
+                    paramsSchema: schemas_1.EnableSectionRequestSchema,
+                    responseSchema: schemas_1.SectionResponseSchema,
+                }, request, { id: String(sectionsUid) });
+            },
+        };
+        /**
+         * User access management endpoints
+         * @description Methods for managing user access permissions to warehouses
+         */
+        this.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: async (warehouseUid, params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/warehouse/{id}/users',
+                    paramsSchema: schemas_1.WarehouseUserListParamsSchema,
+                    responseSchema: schemas_1.WarehouseUserListResponseSchema,
+                }, params, { id: String(warehouseUid) });
+            },
+            /**
+             * 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: async (warehouseUid, request) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/warehouse/{id}/users',
+                    paramsSchema: schemas_1.CreateWarehouseUserRequestSchema,
+                    responseSchema: schemas_1.WarehouseUserResponseSchema,
+                }, request, { id: String(warehouseUid) });
+            },
+        };
+    }
+}
+exports.VMIClient = VMIClient;
+//# sourceMappingURL=client.js.map