@simpleapps-com/augur-api 0.5.1 → 0.7.0

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

@@ -2,8 +2,7 @@
 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");
+const resources_1 = require("./resources");
 /**
  * VMI (Vendor Managed Inventory) API Client
  * @description Client for interacting with VMI microservice API endpoints for warehouse and inventory management
@@ -30,1766 +29,35 @@ class VMIClient extends base_client_1.BaseServiceClient {
      */
     constructor(http, baseUrl = 'https://vmi.augur-api.com') {
         super('vmi', http, baseUrl);
-        /**
-         * OpenAPI Path: /health-check → healthCheck.get
-         * @description Health check endpoint
-         */
-        this.healthCheck = {
-            /**
-             * Service health check
-             * @description Verify service health and trigger seed jobs if needed
-             * @fullPath api.vmi.healthCheck.get
-             * @service vmi
-             * @domain system-health
-             * @discoverable true
-             * @dataMethod healthCheckData.get
-             * @example
-             * ```typescript
-             * const health = await client.healthCheck.get();
-             * console.log('Site:', health.data.siteId, 'Hash:', health.data.siteHash);
-             * ```
-             */
-            get: async () => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/health-check',
-                    responseSchema: schemas_1.HealthCheckResponseSchema,
-                });
-            },
-        };
-        /**
-         * OpenAPI Path: /ping → ping.get
-         * @description Ping endpoint for connectivity test
-         */
-        this.ping = {
-            /**
-             * Simple connectivity test
-             * @description Simple connectivity test endpoint (no authentication required)
-             * @fullPath api.vmi.ping.get
-             * @service vmi
-             * @domain system-health
-             * @discoverable true
-             * @dataMethod pingData.get
-             * @example
-             * ```typescript
-             * const pong = await client.ping.get();
-             * console.log(pong.data); // "pong"
-             * ```
-             */
-            get: async () => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/ping',
-                    responseSchema: schemas_1.PingResponseSchema,
-                });
-            },
-        };
-        /**
-         * Warehouse management endpoints
-         * @description Methods for CRUD operations on warehouses and warehouse configuration
-         */
-        this.warehouse = {
-            /**
-             * 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/{warehouseUid}', 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/{warehouseUid}', 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/{warehouseUid}'),
-            /**
-             * 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/{warehouseUid}/enable',
-                    paramsSchema: schemas_1.EnableWarehouseRequestSchema,
-                    responseSchema: schemas_1.WarehouseResponseSchema,
-                }, request, { warehouseUid: String(warehouseUid) });
-            },
-            // Data-only methods for warehouses
-            /**
-             * List warehouses (data only)
-             * @fullPath api.vmi.warehouse.listData
-             * @service vmi
-             * @domain warehouse-management
-             * @dataMethod Standard method: warehouses.list
-             * @discoverable true
-             * @searchTerms ["warehouses", "facilities", "locations", "storage", "inventory-locations"]
-             * @relatedEndpoints ["api.items.invLoc.list", "api.nexus.transfers.list", "api.legacy.inventory.list"]
-             * @commonPatterns ["Get all warehouses", "List facilities", "Find storage locations"]
-             * @workflow ["warehouse-setup", "inventory-management", "location-management"]
-             * @prerequisites ["Valid authentication token", "Customer ID available"]
-             * @nextSteps ["api.vmi.warehouse.get for details", "api.vmi.inventory.checkAvailability for stock levels"]
-             * @businessRules ["Returns only warehouses accessible to authenticated user", "Supports customer-specific filtering"]
-             * @functionalArea "warehouse-and-inventory-management"
-             * @caching "Cache for 10 minutes, invalidate on warehouse changes"
-             * @performance "Supports pagination, use limit parameter for large datasets"
-             * @description Returns only the data array from warehouses response
-             * @param params Optional filtering and pagination parameters
-             * @returns Array of warehouses (data only)
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const warehouses = await client.warehouses.listData({ customerId: 12345 });
-             * console.log(warehouses); // Direct array access
-             * ```
-             */
-            listData: async (params) => {
-                const response = await this.warehouse.list(params);
-                return response.data;
-            },
-            /**
-             * Get warehouse details (data only)
-             * @fullPath api.vmi.warehouse.getData
-             * @service vmi
-             * @domain warehouse-management
-             * @dataMethod Standard method: warehouses.get
-             * @discoverable true
-             * @searchTerms ["warehouse", "facility", "location", "storage-details"]
-             * @relatedEndpoints ["api.vmi.inventory.checkAvailability", "api.vmi.userAccess.listWarehouseUsers"]
-             * @commonPatterns ["Get warehouse info", "View facility details"]
-             * @description Returns only the data from warehouse details response
-             * @param warehouseUid Warehouse unique identifier
-             * @returns Warehouse details (data only)
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const warehouse = await client.warehouses.getData(123);
-             * console.log(warehouse.warehouse_name); // Direct object access
-             * ```
-             */
-            getData: async (warehouseUid) => {
-                const response = await this.warehouse.get(warehouseUid);
-                return response.data;
-            },
-            /**
-             * Create warehouse (data only)
-             * @fullPath api.vmi.warehouse.createData
-             * @service vmi
-             * @domain warehouse-management
-             * @dataMethod Standard method: warehouses.create
-             * @discoverable true
-             * @searchTerms ["create", "new-warehouse", "facility-setup"]
-             * @relatedEndpoints ["api.vmi.inventoryProfiles.headers.create", "api.vmi.sections.create"]
-             * @commonPatterns ["Setup new warehouse", "Add facility"]
-             * @description Returns only the data from warehouse creation response
-             * @param request Warehouse creation data
-             * @returns Created warehouse information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * const warehouse = await client.warehouses.createData({
-             *   warehouse_name: 'New Facility',
-             *   customer_id: 12345
-             * });
-             * console.log(warehouse.warehouseUid); // Direct access to created ID
-             * ```
-             */
-            createData: async (request) => {
-                const response = await this.warehouse.create(request);
-                return response.data;
-            },
-            /**
-             * Update warehouse (data only)
-             * @fullPath api.vmi.warehouse.updateData
-             * @service vmi
-             * @domain warehouse-management
-             * @dataMethod Standard method: warehouses.update
-             * @discoverable true
-             * @searchTerms ["update", "modify-warehouse", "edit-facility"]
-             * @relatedEndpoints ["api.vmi.warehouses.get", "api.vmi.warehouses.enable"]
-             * @commonPatterns ["Update warehouse info", "Modify facility details"]
-             * @description Returns only the data from warehouse update response
-             * @param warehouseUid Warehouse unique identifier
-             * @param request Warehouse update data
-             * @returns Updated warehouse information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * const warehouse = await client.warehouses.updateData(123, {
-             *   warehouse_desc: 'Updated description'
-             * });
-             * console.log(warehouse.date_last_modified); // Direct access to updated fields
-             * ```
-             */
-            updateData: async (warehouseUid, request) => {
-                const response = await this.warehouse.update(warehouseUid, request);
-                return response.data;
-            },
-            /**
-             * Enable/disable warehouse (data only)
-             * @fullPath api.vmi.warehouse.enableData
-             * @service vmi
-             * @domain warehouse-management
-             * @dataMethod Standard method: warehouses.enable
-             * @discoverable true
-             * @searchTerms ["enable", "disable", "warehouse-status", "activate-facility"]
-             * @relatedEndpoints ["api.vmi.warehouses.get", "api.vmi.warehouses.update"]
-             * @commonPatterns ["Activate warehouse", "Disable facility", "Change warehouse status"]
-             * @description Returns only the data from warehouse status change response
-             * @param warehouseUid Warehouse unique identifier
-             * @param request Status change request
-             * @returns Updated warehouse information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * const warehouse = await client.warehouses.enableData(123, { status_cd: 704 });
-             * console.log(warehouse.status_cd); // Direct access to updated status
-             * ```
-             */
-            enableData: async (warehouseUid, request) => {
-                const response = await this.warehouse.enable(warehouseUid, request);
-                return response.data;
-            },
-            /**
-             * Warehouse availability endpoints
-             * @description Methods for checking inventory availability in warehouses
-             */
-            availability: {
-                /**
-                 * 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.warehouse.availability.get(123, { q: 'wire' });
-                 * items.forEach(item => {
-                 *   console.log(`${item.itemId}: ${item.qtyOnHand} ${item.defaultSellingUnit}`);
-                 * });
-                 * ```
-                 */
-                get: async (warehouseUid, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: '/warehouse/{warehouseUid}/availability',
-                        paramsSchema: schemas_1.InventoryAvailabilityParamsSchema,
-                        responseSchema: schemas_1.InventoryAvailabilityResponseSchema,
-                    }, params, { warehouseUid: String(warehouseUid) });
-                },
-                /**
-                 * Check inventory availability (data only)
-                 * @fullPath api.vmi.warehouse.availability.getData
-                 * @service vmi
-                 * @domain inventory-management
-                 * @dataMethod Standard method: warehouse.availability.get
-                 * @discoverable true
-                 * @searchTerms ["inventory", "availability", "stock-check", "item-search"]
-                 * @relatedEndpoints ["api.items.products.list", "api.legacy.inventory.list", "api.vmi.warehouse.adjust.create"]
-                 * @commonPatterns ["Check stock levels", "Search inventory", "Find available items"]
-                 * @workflow ["inventory-lookup", "stock-verification", "item-availability-check"]
-                 * @prerequisites ["Valid authentication token", "Warehouse access permissions"]
-                 * @nextSteps ["api.vmi.warehouse.adjust.create for quantity changes", "api.vmi.warehouse.usage.create for consumption"]
-                 * @businessRules ["Returns only items matching search query", "Requires warehouse access permissions"]
-                 * @functionalArea "inventory-and-stock-management"
-                 * @caching "Real-time data, do not cache"
-                 * @performance "Use specific search terms to limit results"
-                 * @description Returns only the data array from inventory availability response
-                 * @param warehouseUid Warehouse unique identifier
-                 * @param params Search parameters including query string
-                 * @returns Array of available inventory items (data only)
-                 * @throws ValidationError When parameters are invalid or response is malformed
-                 * @example
-                 * ```typescript
-                 * const items = await client.warehouse.availability.getData(123, { q: 'wire' });
-                 * console.log(items); // Direct array access
-                 * ```
-                 */
-                getData: async (warehouseUid, params) => {
-                    const response = await this.warehouse.availability.get(warehouseUid, params);
-                    return response.data;
-                },
-            },
-            /**
-             * Warehouse adjust endpoints
-             * @description Methods for adjusting inventory quantities
-             */
-            adjust: {
-                /**
-                 * 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.warehouse.adjust.create(123, {
-                 *   adjustments: [
-                 *     {
-                 *       invMastUid: 456,
-                 *       qty_on_hand: 200.0,
-                 *       reason: 'Physical count adjustment'
-                 *     },
-                 *     {
-                 *       invMastUid: 789,
-                 *       qty_on_hand: 150.0,
-                 *       reason: 'Damage correction'
-                 *     }
-                 *   ]
-                 * });
-                 * ```
-                 */
-                create: async (warehouseUid, request) => {
-                    await this.executeRequest({
-                        method: 'POST',
-                        path: '/warehouse/{warehouseUid}/adjust',
-                        paramsSchema: schemas_1.InventoryAdjustRequestSchema,
-                        responseSchema: zod_1.z.boolean(),
-                    }, request, { warehouseUid: String(warehouseUid) });
-                    return true;
-                },
-            },
-            /**
-             * Warehouse receive endpoints
-             * @description Methods for receiving inventory into warehouses
-             */
-            receive: {
-                /**
-                 * 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.warehouse.receive.create(123, {
-                 *   receipts: [
-                 *     {
-                 *       invMastUid: 456,
-                 *       qty_received: 50.0,
-                 *       po_number: 'PO-2024-001',
-                 *       lot_number: 'LOT-456'
-                 *     }
-                 *   ]
-                 * });
-                 * ```
-                 */
-                create: async (warehouseUid, request) => {
-                    await this.executeRequest({
-                        method: 'POST',
-                        path: '/warehouse/{warehouseUid}/receive',
-                        paramsSchema: schemas_1.InventoryReceiveRequestSchema,
-                        responseSchema: zod_1.z.boolean(),
-                    }, request, { warehouseUid: String(warehouseUid) });
-                    return true;
-                },
-            },
-            /**
-             * Warehouse replenish endpoints
-             * @description Methods for warehouse replenishment operations
-             */
-            replenish: {
-                /**
-                 * 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.warehouse.replenish.get(123, { distributorsUid: 789 });
-                 * replenishment.replenishment_items.forEach(item => {
-                 *   console.log(`${item.itemId}: Need ${item.suggestedOrderQty} (current: ${item.qtyOnHand})`);
-                 * });
-                 * ```
-                 */
-                get: async (warehouseUid, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: '/warehouse/{warehouseUid}/replenish',
-                        paramsSchema: schemas_1.ReplenishmentParamsSchema,
-                        responseSchema: schemas_1.ReplenishmentInfoResponseSchema,
-                    }, params, { warehouseUid: 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.warehouse.replenish.create(123, {
-                 *   distributor_uid: 789,
-                 *   restock_items: [
-                 *     { invMastUid: 456, qtyToOrder: 100.0 },
-                 *     { invMastUid: 789, qtyToOrder: 75.0 }
-                 *   ]
-                 * });
-                 * ```
-                 */
-                create: async (warehouseUid, request) => {
-                    await this.executeRequest({
-                        method: 'POST',
-                        path: '/warehouse/{warehouseUid}/replenish',
-                        paramsSchema: schemas_1.ReplenishRequestSchema,
-                        responseSchema: zod_1.z.boolean(),
-                    }, request, { warehouseUid: String(warehouseUid) });
-                    return true;
-                },
-                /**
-                 * Get replenishment information (data only)
-                 * @fullPath api.vmi.warehouse.replenish.getData
-                 * @service vmi
-                 * @domain inventory-management
-                 * @dataMethod Standard method: warehouse.replenish.get
-                 * @discoverable true
-                 * @searchTerms ["replenishment", "restock", "min-max", "reorder-points"]
-                 * @relatedEndpoints ["api.vmi.warehouse.replenish.create", "api.vmi.invProfileHdr.invProfileLine.list"]
-                 * @commonPatterns ["Check restock needs", "Get replenishment suggestions", "Find low inventory"]
-                 * @workflow ["replenishment-planning", "inventory-optimization", "stock-level-monitoring"]
-                 * @prerequisites ["Valid authentication token", "Warehouse access permissions", "Inventory profiles configured"]
-                 * @nextSteps ["api.vmi.warehouse.replenish.create to execute restocking", "api.vmi.warehouse.adjust.create for manual corrections"]
-                 * @businessRules ["Based on min/max quantities from inventory profiles", "Considers current stock levels and demand"]
-                 * @functionalArea "inventory-and-replenishment-management"
-                 * @caching "Cache for 5 minutes, invalidate on inventory changes"
-                 * @performance "May be slow for large inventories, consider filtering by distributor"
-                 * @description Returns only the data from replenishment information response
-                 * @param warehouseUid Warehouse unique identifier
-                 * @param params Optional filtering by distributor
-                 * @returns Replenishment information with suggested quantities (data only)
-                 * @throws ValidationError When parameters are invalid or response is malformed
-                 * @example
-                 * ```typescript
-                 * const replenish = await client.warehouse.replenish.getData(123);
-                 * console.log(replenish.replenishment_items); // Direct access to restock suggestions
-                 * ```
-                 */
-                getData: async (warehouseUid, params) => {
-                    const response = await this.warehouse.replenish.get(warehouseUid, params);
-                    return response.data;
-                },
-            },
-            /**
-             * Warehouse transfer endpoints
-             * @description Methods for transferring inventory between warehouses
-             */
-            transfer: {
-                /**
-                 * 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.warehouse.transfer.create(123, {
-                 *   toWarehouseUid: 124,
-                 *   transfers: [
-                 *     {
-                 *       invMastUid: 456,
-                 *       qty_to_transfer: 25.0,
-                 *       reason: 'Stock balancing'
-                 *     }
-                 *   ]
-                 * });
-                 * ```
-                 */
-                create: async (warehouseUid, request) => {
-                    await this.executeRequest({
-                        method: 'POST',
-                        path: '/warehouse/{warehouseUid}/transfer',
-                        paramsSchema: schemas_1.TransferRequestSchema,
-                        responseSchema: zod_1.z.boolean(),
-                    }, request, { warehouseUid: String(warehouseUid) });
-                    return true;
-                },
-            },
-            /**
-             * Warehouse usage endpoints
-             * @description Methods for recording inventory usage
-             */
-            usage: {
-                /**
-                 * 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.warehouse.usage.create(123, {
-                 *   job_description: 'Office Renovation - Building A',
-                 *   department: 'Facilities',
-                 *   usage_items: [
-                 *     {
-                 *       invMastUid: 456,
-                 *       inv_profile_line_type: 'prophet21',
-                 *       qty_used: 5.0
-                 *     },
-                 *     {
-                 *       invMastUid: 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'
-                 *       }
-                 *     }
-                 *   ]
-                 * });
-                 * ```
-                 */
-                create: async (warehouseUid, request) => {
-                    await this.executeRequest({
-                        method: 'POST',
-                        path: '/warehouse/{warehouseUid}/usage',
-                        paramsSchema: schemas_1.UsageRequestSchema,
-                        responseSchema: zod_1.z.boolean(),
-                    }, request, { warehouseUid: String(warehouseUid) });
-                    return true;
-                },
-            },
-            /**
-             * Warehouse users endpoints
-             * @description Methods for managing user access permissions to warehouses
-             */
-            users: {
-                /**
-                 * 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.warehouse.users.list(123, { limit: 20 });
-                 * users.forEach(user => {
-                 *   console.log(`User ${user.users_id} - Status: ${user.status_cd}`);
-                 * });
-                 * ```
-                 */
-                list: async (warehouseUid, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: '/warehouse/{warehouseUid}/users',
-                        paramsSchema: schemas_1.WarehouseUserListParamsSchema,
-                        responseSchema: schemas_1.WarehouseUserListResponseSchema,
-                    }, params, { warehouseUid: 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.warehouse.users.create(123, {
-                 *   users_id: 456,
-                 *   status_cd: 704
-                 * });
-                 *
-                 * // Grant access
-                 * const access2 = await client.warehouse.users.create(123, {
-                 *   users_id: 456,
-                 *   status_cd: 704
-                 * });
-                 * ```
-                 */
-                create: async (warehouseUid, request) => {
-                    return this.executeRequest({
-                        method: 'POST',
-                        path: '/warehouse/{warehouseUid}/users',
-                        paramsSchema: schemas_1.CreateWarehouseUserRequestSchema,
-                        responseSchema: schemas_1.WarehouseUserResponseSchema,
-                    }, request, { warehouseUid: String(warehouseUid) });
-                },
-                /**
-                 * List warehouse users (data only)
-                 * @description Returns only the data array from warehouse users response
-                 * @param warehouseUid Warehouse unique identifier
-                 * @param params Optional filtering and pagination parameters
-                 * @returns Array of warehouse user access records (data only)
-                 * @throws ValidationError When parameters are invalid or response is malformed
-                 */
-                listData: async (warehouseUid, params) => {
-                    const response = await this.warehouse.users.list(warehouseUid, params);
-                    return response.data;
-                },
-                /**
-                 * Create warehouse user access (data only)
-                 * @description Returns only the data from warehouse user access creation response
-                 * @param warehouseUid Warehouse unique identifier
-                 * @param request User access request data
-                 * @returns Created or updated warehouse user access information (data only)
-                 * @throws ValidationError When request is invalid or response is malformed
-                 */
-                createData: async (warehouseUid, request) => {
-                    const response = (await this.warehouse.users.create(warehouseUid, request));
-                    return response.data;
-                },
-            },
-        };
-        /**
-         * Distributor management endpoints
-         * @description Methods for CRUD operations on distributors and supplier relationships
-         */
-        this.distributors = {
-            /**
-             * List distributors with filtering
-             * @description Returns distributors for a customer with optional status filtering and pagination
-             * @param params Filtering and pagination parameters (customerId is required)
-             * @returns Array of distributor objects
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const distributors = await client.distributors.list({ customerId: 12345 });
-             * distributors.forEach(dist => {
-             *   console.log(`${dist.distributor_name}: ${dist.contact_email}`);
-             * });
-             * ```
-             */
-            list: this.createListMethod('/distributors', schemas_1.DistributorListParamsSchema, schemas_1.DistributorListResponseSchema),
-            /**
-             * Get distributor details by ID
-             * @description Returns detailed information for a specific distributor
-             * @param distributorsUid Distributor unique identifier
-             * @returns Distributor details
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const distributor = await client.distributors.get(789);
-             * console.log(distributor.distributorsName, distributor.distributorsEmail);
-             * ```
-             */
-            get: this.createGetMethod('/distributors/{distributorsUid}', 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({
-             *   distributorsName: 'ABC Supply Co',
-             *   distributorsDesc: 'Primary electrical supplier',
-             *   customerId: 12345,
-             *   distributorsEmail: 'orders@abcsupply.com',
-             *   distributorsAccount: 'ACC-123'
-             * });
-             * ```
-             */
-            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, {
-             *   distributorsEmail: 'newemail@abcsupply.com',
-             *   distributorsAccount: 'ACC-456'
-             * });
-             * ```
-             */
-            update: this.createUpdateMethod('/distributors/{distributorsUid}', 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/{distributorsUid}'),
-            /**
-             * 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, { statusCd: 705 }); // Disable
-             * await client.distributors.enable(789, { statusCd: 704 }); // Enable
-             * ```
-             */
-            enable: async (distributorsUid, request) => {
-                return this.executeRequest({
-                    method: 'PUT',
-                    path: '/distributors/{distributorsUid}/enable',
-                    paramsSchema: schemas_1.EnableDistributorRequestSchema,
-                    responseSchema: schemas_1.DistributorResponseSchema,
-                }, request, { distributorsUid: String(distributorsUid) });
-            },
-            // Data-only methods for distributors
-            /**
-             * List distributors (data only)
-             * @fullPath api.vmi.distributors.listData
-             * @service vmi
-             * @domain supplier-management
-             * @dataMethod Standard method: distributors.list
-             * @discoverable true
-             * @searchTerms ["distributors", "suppliers", "vendors", "partners"]
-             * @relatedEndpoints ["api.vmi.products.list", "api.vmi.inventory.replenish", "api.vmi.restocking.list"]
-             * @commonPatterns ["Get all suppliers", "List vendors", "Find distributors"]
-             * @workflow ["supplier-management", "vendor-setup", "distributor-onboarding"]
-             * @prerequisites ["Valid authentication token", "Customer ID available"]
-             * @nextSteps ["api.vmi.distributors.get for details", "api.vmi.products.list for distributor products"]
-             * @businessRules ["Returns only distributors associated with customer", "Supports status filtering"]
-             * @functionalArea "supplier-and-vendor-management"
-             * @caching "Cache for 15 minutes, invalidate on distributor changes"
-             * @performance "Supports pagination for large distributor lists"
-             * @description Returns only the data array from distributors response
-             * @param params Filtering and pagination parameters
-             * @returns Array of distributors (data only)
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const distributors = await client.distributors.listData({ customerId: 12345 });
-             * console.log(distributors); // Direct array access
-             * ```
-             */
-            listData: async (params) => {
-                const response = await this.distributors.list(params);
-                return response.data;
-            },
-            /**
-             * Get distributor details (data only)
-             * @fullPath api.vmi.distributors.getData
-             * @service vmi
-             * @domain supplier-management
-             * @dataMethod Standard method: distributors.get
-             * @discoverable true
-             * @searchTerms ["distributor", "supplier", "vendor", "partner-details"]
-             * @relatedEndpoints ["api.vmi.products.list", "api.vmi.inventory.getReplenishmentInfo"]
-             * @commonPatterns ["Get supplier info", "View distributor details"]
-             * @description Returns only the data from distributor details response
-             * @param distributorsUid Distributor unique identifier
-             * @returns Distributor details (data only)
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const distributor = await client.distributors.getData(789);
-             * console.log(distributor.distributors_name); // Direct object access
-             * ```
-             */
-            getData: async (distributorsUid) => {
-                const response = await this.distributors.get(distributorsUid);
-                return response.data;
-            },
-            /**
-             * Create distributor (data only)
-             * @fullPath api.vmi.distributors.createData
-             * @service vmi
-             * @domain supplier-management
-             * @dataMethod Standard method: distributors.create
-             * @discoverable true
-             * @searchTerms ["create", "new-distributor", "add-supplier"]
-             * @relatedEndpoints ["api.vmi.products.createForDistributor", "api.vmi.restocking.create"]
-             * @commonPatterns ["Add new supplier", "Setup distributor"]
-             * @description Returns only the data from distributor creation response
-             * @param request Distributor creation data
-             * @returns Created distributor information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * const distributor = await client.distributors.createData({
-             *   distributors_name: 'ABC Supply Co',
-             *   customer_id: 12345
-             * });
-             * console.log(distributor.distributorsUid); // Direct access to created ID
-             * ```
-             */
-            createData: async (request) => {
-                const response = await this.distributors.create(request);
-                return response.data;
-            },
-            /**
-             * Update distributor (data only)
-             * @fullPath api.vmi.distributors.updateData
-             * @service vmi
-             * @domain supplier-management
-             * @dataMethod Standard method: distributors.update
-             * @discoverable true
-             * @searchTerms ["update", "modify-distributor", "edit-supplier"]
-             * @relatedEndpoints ["api.vmi.distributors.get", "api.vmi.distributors.enable"]
-             * @commonPatterns ["Update supplier info", "Modify distributor details"]
-             * @description Returns only the data from distributor update response
-             * @param distributorsUid Distributor unique identifier
-             * @param request Distributor update data
-             * @returns Updated distributor information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * const distributor = await client.distributors.updateData(789, {
-             *   distributors_email: 'new@email.com'
-             * });
-             * console.log(distributor.date_last_modified); // Direct access to updated fields
-             * ```
-             */
-            updateData: async (distributorsUid, request) => {
-                const response = await this.distributors.update(distributorsUid, request);
-                return response.data;
-            },
-            /**
-             * Enable/disable distributor (data only)
-             * @fullPath api.vmi.distributors.enableData
-             * @service vmi
-             * @domain supplier-management
-             * @dataMethod Standard method: distributors.enable
-             * @discoverable true
-             * @searchTerms ["enable", "disable", "distributor-status", "activate-supplier"]
-             * @relatedEndpoints ["api.vmi.distributors.get", "api.vmi.distributors.update"]
-             * @commonPatterns ["Activate distributor", "Disable supplier", "Change distributor status"]
-             * @description Returns only the data from distributor status change response
-             * @param distributorsUid Distributor unique identifier
-             * @param request Status change request
-             * @returns Updated distributor information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * const distributor = await client.distributors.enableData(789, { status_cd: 704 });
-             * console.log(distributor.status_cd); // Direct access to updated status
-             * ```
-             */
-            enableData: async (distributorsUid, request) => {
-                const response = await this.distributors.enable(distributorsUid, request);
-                return response.data;
-            },
-            /**
-             * Distributor products endpoints
-             * @description Methods for managing products associated with distributors
-             */
-            products: {
-                /**
-                 * 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.distributors.products.create(789, {
-                 *   product_id: 'PROD-001',
-                 *   product_name: 'New Product',
-                 *   product_desc: 'Product description',
-                 *   distributorsUid: 789,
-                 *   customer_id: 12345
-                 * });
-                 * ```
-                 */
-                create: async (distributorsUid, request) => {
-                    return this.executeRequest({
-                        method: 'POST',
-                        path: '/distributors/{distributorsUid}/products',
-                        paramsSchema: schemas_1.CreateProductRequestSchema,
-                        responseSchema: schemas_1.ProductResponseSchema,
-                    }, request, { distributorsUid: String(distributorsUid) });
-                },
-                /**
-                 * Create distributor product (data only)
-                 * @description Returns only the data from distributor product creation response
-                 * @param distributorsUid Distributor unique identifier
-                 * @param request Product creation data
-                 * @returns Created product information (data only)
-                 * @throws ValidationError When request is invalid or response is malformed
-                 */
-                createData: async (distributorsUid, request) => {
-                    const response = await this.distributors.products.create(distributorsUid, request);
-                    return response.data;
-                },
-            },
-        };
-        /**
-         * Product management endpoints
-         * @description Methods for CRUD operations on products and product search functionality
-         */
-        this.products = {
-            /**
-             * List products with filtering
-             * @description Returns products for a customer and distributor with optional filtering and pagination
-             * @param params Filtering and pagination parameters (customerId and distributorsUid are required)
-             * @returns Array of product objects
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const products = await client.products.list({
-             *   customerId: 12345,
-             *   distributorsUid: 789,
-             *   prefix: 'WIRE',
-             *   limit: 20
-             * });
-             * ```
-             */
-            list: this.createListMethod('/products', schemas_1.ProductListParamsSchema, schemas_1.ProductListResponseSchema),
-            /**
-             * Products find endpoints
-             * @description Methods for searching products across VMI and Prophet 21
-             */
-            find: {
-                /**
-                 * 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.get({
-                 *   customerId: 12345,
-                 *   prefix: 'WIRE'
-                 * });
-                 *
-                 * items.forEach(item => {
-                 *   console.log(`${item.itemId} (${item.type}): ${item.description}`);
-                 * });
-                 * ```
-                 */
-                get: async (params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: '/products/find',
-                        paramsSchema: schemas_1.ProductFindParamsSchema,
-                        responseSchema: schemas_1.ProductFindResponseSchema,
-                    }, params);
-                },
-                /**
-                 * Find products and items (data only)
-                 * @fullPath api.vmi.products.find.getData
-                 * @service vmi
-                 * @domain product-management
-                 * @dataMethod Standard method: products.find.get
-                 * @discoverable true
-                 * @searchTerms ["search", "find-products", "item-lookup", "product-search"]
-                 * @relatedEndpoints ["api.vmi.products.list", "api.items.products.list"]
-                 * @commonPatterns ["Search products", "Find items", "Product lookup"]
-                 * @description Returns only the data array from product search response
-                 * @param params Search parameters
-                 * @returns Array of found items (data only)
-                 * @throws ValidationError When parameters are invalid or response is malformed
-                 * @example
-                 * ```typescript
-                 * const items = await client.products.find.getData({ customerId: 12345, prefix: 'WIRE' });
-                 * console.log(items); // Direct array access
-                 * ```
-                 */
-                getData: async (params) => {
-                    const response = await this.products.find.get(params);
-                    return response.data;
-                },
-            },
-            /**
-             * 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.partNumber, product.productsDesc);
-             * ```
-             */
-            get: this.createGetMethod('/products/{productsUid}', 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, {
-             *   partNumber: 'PN-456',
-             *   productsDesc: 'Updated description'
-             * });
-             * ```
-             */
-            update: this.createUpdateMethod('/products/{productsUid}', 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/{productsUid}'),
-            /**
-             * 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, { statusCd: 705 }); // Disable
-             * await client.products.enable(456, { statusCd: 704 }); // Enable
-             * ```
-             */
-            enable: async (productsUid, request) => {
-                return this.executeRequest({
-                    method: 'PUT',
-                    path: '/products/{productsUid}/enable',
-                    paramsSchema: schemas_1.EnableProductRequestSchema,
-                    responseSchema: schemas_1.ProductResponseSchema,
-                }, request, { productsUid: String(productsUid) });
-            },
-            // Data-only methods for products
-            /**
-             * List products (data only)
-             * @fullPath api.vmi.products.listData
-             * @service vmi
-             * @domain product-management
-             * @dataMethod Standard method: products.list
-             * @discoverable true
-             * @searchTerms ["products", "items", "catalog", "inventory-items"]
-             * @relatedEndpoints ["api.items.products.list", "api.vmi.inventory.checkAvailability"]
-             * @commonPatterns ["Get all products", "List catalog items", "Browse inventory products"]
-             * @description Returns only the data array from products response
-             * @param params Filtering and pagination parameters
-             * @returns Array of products (data only)
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const products = await client.products.listData({ customerId: 12345, distributorsUid: 789 });
-             * console.log(products); // Direct array access
-             * ```
-             */
-            listData: async (params) => {
-                const response = await this.products.list(params);
-                return response.data;
-            },
-            /**
-             * Get product details (data only)
-             * @fullPath api.vmi.products.getData
-             * @service vmi
-             * @domain product-management
-             * @dataMethod Standard method: products.get
-             * @discoverable true
-             * @searchTerms ["product", "item-details", "product-info"]
-             * @relatedEndpoints ["api.vmi.products.list", "api.vmi.inventory.checkAvailability"]
-             * @commonPatterns ["Get product info", "View item details"]
-             * @description Returns only the data from product details response
-             * @param productsUid Product unique identifier
-             * @returns Product details (data only)
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const product = await client.products.getData(456);
-             * console.log(product.products_name); // Direct object access
-             * ```
-             */
-            getData: async (productsUid) => {
-                const response = await this.products.get(productsUid);
-                return response.data;
-            },
-        };
-        /**
-         * Inventory Profile management endpoints
-         * @description Methods for managing inventory profiles that define min/max/reorder quantities for automated replenishment
-         */
-        this.invProfileHdr = {
-            /**
-             * 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.invProfileHdr.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.invProfileHdr.get(1);
-             * console.log(header.invProfileHdrDesc);
-             * ```
-             */
-            get: this.createGetMethod('/inv-profile-hdr/{invProfileHdrUid}', 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.invProfileHdr.create({
-             *   invProfileHdrDesc: 'Standard Office Setup Profile',
-             *   customerId: 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.invProfileHdr.update(1, {
-             *   invProfileHdrDesc: 'Updated Profile Description'
-             * });
-             * ```
-             */
-            update: this.createUpdateMethod('/inv-profile-hdr/{invProfileHdrUid}', 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.invProfileHdr.delete(1);
-             * ```
-             */
-            delete: this.createDeleteBooleanMethod('/inv-profile-hdr/{invProfileHdrUid}'),
-            // Data-only methods for inventory profile headers
-            /**
-             * List inventory profile headers (data only)
-             * @description Returns only the data array from inventory profile headers response
-             * @param params Filtering and pagination parameters
-             * @returns Array of inventory profile headers (data only)
-             * @throws ValidationError When parameters are invalid or response is malformed
-             */
-            listData: async (params) => {
-                const response = await this.invProfileHdr.list(params);
-                return response.data;
-            },
-            /**
-             * Get inventory profile header details (data only)
-             * @description Returns only the data from inventory profile header details response
-             * @param invProfileHdrUid Inventory profile header unique identifier
-             * @returns Inventory profile header details (data only)
-             * @throws ValidationError When response is malformed
-             */
-            getData: async (invProfileHdrUid) => {
-                const response = await this.invProfileHdr.get(invProfileHdrUid);
-                return response.data;
-            },
-            /**
-             * Create inventory profile header (data only)
-             * @description Returns only the data from inventory profile header creation response
-             * @param request Inventory profile header creation data
-             * @returns Created inventory profile header information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             */
-            createData: async (request) => {
-                const response = await this.invProfileHdr.create(request);
-                return response.data;
-            },
-            /**
-             * Update inventory profile header (data only)
-             * @description Returns only the data from inventory profile header update response
-             * @param invProfileHdrUid Inventory profile header unique identifier
-             * @param request Inventory profile header update data
-             * @returns Updated inventory profile header information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             */
-            updateData: async (invProfileHdrUid, request) => {
-                const response = await this.invProfileHdr.update(invProfileHdrUid, request);
-                return response.data;
-            },
-            /**
-             * Inventory profile lines sub-endpoints
-             * @description Methods for managing inventory profile lines (individual item configurations within headers)
-             */
-            invProfileLine: {
-                /**
-                 * 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.invProfileHdr.invProfileLine.list(1, { limit: 20 });
-                 * lines.forEach(line => {
-                 *   console.log(`Item ${line.invMastUid}: Min ${line.minQty}, Max ${line.maxQty}`);
-                 * });
-                 * ```
-                 */
-                list: async (invProfileHdrUid, params) => {
-                    return this.executeRequest({
-                        method: 'GET',
-                        path: '/inv-profile-hdr/{invProfileHdrUid}/inv-profile-line',
-                        paramsSchema: schemas_1.InvProfileLineListParamsSchema,
-                        responseSchema: schemas_1.InvProfileLineListResponseSchema,
-                    }, params, { invProfileHdrUid: 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.invProfileHdr.invProfileLine.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/{invProfileHdrUid}/inv-profile-line/{invProfileLineUid}',
-                        responseSchema: schemas_1.InvProfileLineResponseSchema,
-                    }, undefined, {
-                        invProfileHdrUid: String(invProfileHdrUid),
-                        invProfileLineUid: 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.invProfileHdr.invProfileLine.create(1, {
-                 *   invMastUid: 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/{invProfileHdrUid}/inv-profile-line',
-                        paramsSchema: schemas_1.CreateInvProfileLineRequestSchema,
-                        responseSchema: schemas_1.InvProfileLineResponseSchema,
-                    }, request, { invProfileHdrUid: 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.invProfileHdr.invProfileLine.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/{invProfileHdrUid}/inv-profile-line/{invProfileLineUid}',
-                        paramsSchema: schemas_1.UpdateInvProfileLineRequestSchema,
-                        responseSchema: schemas_1.InvProfileLineResponseSchema,
-                    }, request, {
-                        invProfileHdrUid: String(invProfileHdrUid),
-                        invProfileLineUid: 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.invProfileHdr.invProfileLine.delete(1, 10);
-                 * ```
-                 */
-                delete: async (invProfileHdrUid, invProfileLineUid) => {
-                    await this.executeRequest({
-                        method: 'DELETE',
-                        path: '/inv-profile-hdr/{invProfileHdrUid}/inv-profile-line/{invProfileLineUid}',
-                        responseSchema: zod_1.z.unknown(),
-                    }, undefined, {
-                        invProfileHdrUid: String(invProfileHdrUid),
-                        invProfileLineUid: String(invProfileLineUid),
-                    });
-                    return true;
-                },
-                // Data-only methods for inventory profile lines
-                /**
-                 * List inventory profile lines (data only)
-                 * @description Returns only the data array from inventory profile lines response
-                 * @param invProfileHdrUid Inventory profile header unique identifier
-                 * @param params Optional pagination parameters
-                 * @returns Array of inventory profile lines (data only)
-                 * @throws ValidationError When parameters are invalid or response is malformed
-                 */
-                listData: async (invProfileHdrUid, params) => {
-                    const response = await this.invProfileHdr.invProfileLine.list(invProfileHdrUid, params);
-                    return response.data;
-                },
-                /**
-                 * Get inventory profile line details (data only)
-                 * @description Returns only the data from inventory profile line details response
-                 * @param invProfileHdrUid Inventory profile header unique identifier
-                 * @param invProfileLineUid Inventory profile line unique identifier
-                 * @returns Inventory profile line details (data only)
-                 * @throws ValidationError When response is malformed
-                 */
-                getData: async (invProfileHdrUid, invProfileLineUid) => {
-                    const response = await this.invProfileHdr.invProfileLine.get(invProfileHdrUid, invProfileLineUid);
-                    return response.data;
-                },
-                /**
-                 * Create inventory profile line (data only)
-                 * @description Returns only the data from inventory profile line creation response
-                 * @param invProfileHdrUid Inventory profile header unique identifier
-                 * @param request Inventory profile line creation data
-                 * @returns Created inventory profile line information (data only)
-                 * @throws ValidationError When request is invalid or response is malformed
-                 */
-                createData: async (invProfileHdrUid, request) => {
-                    const response = await this.invProfileHdr.invProfileLine.create(invProfileHdrUid, request);
-                    return response.data;
-                },
-                /**
-                 * Update inventory profile line (data only)
-                 * @description Returns only the data from inventory profile line update response
-                 * @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 (data only)
-                 * @throws ValidationError When request is invalid or response is malformed
-                 */
-                updateData: async (invProfileHdrUid, invProfileLineUid, request) => {
-                    const response = await this.invProfileHdr.invProfileLine.update(invProfileHdrUid, invProfileLineUid, request);
-                    return response.data;
-                },
-            },
-        };
-        /**
-         * Restocking management endpoints
-         * @description Methods for managing restock headers and replenishment operations
-         */
-        this.restockHdr = {
-            /**
-             * 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.restockHdr.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.restockHdr.get(100);
-             * console.log(`Warehouse: ${header.warehouseUid}, Distributor: ${header.distributorsUid}`);
-             * ```
-             */
-            get: this.createGetMethod('/restock-hdr/{restockHdrUid}', 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.restockHdr.create({
-             *   warehouseUid: 123,
-             *   distributorsUid: 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.restockHdr.update(100, {
-             *   warehouseUid: 124
-             * });
-             * ```
-             */
-            update: this.createUpdateMethod('/restock-hdr/{restockHdrUid}', 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.restockHdr.delete(100);
-             * ```
-             */
-            delete: this.createDeleteBooleanMethod('/restock-hdr/{restockHdrUid}'),
-            // Data-only methods for restocking
-            /**
-             * List restock headers (data only)
-             * @description Returns only the data array from restock headers response
-             * @param params Optional filtering and pagination parameters
-             * @returns Array of restock headers (data only)
-             * @throws ValidationError When parameters are invalid or response is malformed
-             */
-            listData: async (params) => {
-                const response = await this.restockHdr.list(params);
-                return response.data;
-            },
-            /**
-             * Get restock header details (data only)
-             * @description Returns only the data from restock header details response
-             * @param restockHdrUid Restock header unique identifier
-             * @returns Restock header details (data only)
-             * @throws ValidationError When response is malformed
-             */
-            getData: async (restockHdrUid) => {
-                const response = await this.restockHdr.get(restockHdrUid);
-                return response.data;
-            },
-            /**
-             * Create restock header (data only)
-             * @description Returns only the data from restock header creation response
-             * @param request Restock header creation data
-             * @returns Created restock header information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             */
-            createData: async (request) => {
-                const response = await this.restockHdr.create(request);
-                return response.data;
-            },
-            /**
-             * Update restock header (data only)
-             * @description Returns only the data from restock header update response
-             * @param restockHdrUid Restock header unique identifier
-             * @param request Restock header update data
-             * @returns Updated restock header information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             */
-            updateData: async (restockHdrUid, request) => {
-                const response = await this.restockHdr.update(restockHdrUid, request);
-                return response.data;
-            },
-        };
-        /**
-         * 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.sectionName}: ${section.sectionDesc}`);
-             * });
-             * ```
-             */
-            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.sectionName, section.sectionDesc);
-             * ```
-             */
-            get: this.createGetMethod('/sections/{sectionsUid}', 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({
-             *   sectionName: 'Electronics Section',
-             *   sectionDesc: 'Electronic components and devices',
-             *   customerId: 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, {
-             *   sectionName: 'Updated Section Name',
-             *   sectionDesc: 'Updated description'
-             * });
-             * ```
-             */
-            update: this.createUpdateMethod('/sections/{sectionsUid}', 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/{sectionsUid}'),
-            /**
-             * 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, { statusCd: 705 }); // Disable
-             * await client.sections.enable(200, { statusCd: 704 }); // Enable
-             * ```
-             */
-            enable: async (sectionsUid, request) => {
-                return this.executeRequest({
-                    method: 'PUT',
-                    path: '/sections/{sectionsUid}/enable',
-                    paramsSchema: schemas_1.EnableSectionRequestSchema,
-                    responseSchema: schemas_1.SectionResponseSchema,
-                }, request, { sectionsUid: String(sectionsUid) });
-            },
-            // Data-only methods for sections
-            /**
-             * List sections (data only)
-             * @description Returns only the data array from sections response
-             * @param params Filtering and pagination parameters
-             * @returns Array of sections (data only)
-             * @throws ValidationError When parameters are invalid or response is malformed
-             */
-            listData: async (params) => {
-                const response = await this.sections.list(params);
-                return response.data;
-            },
-            /**
-             * Get section details (data only)
-             * @description Returns only the data from section details response
-             * @param sectionsUid Section unique identifier
-             * @returns Section details (data only)
-             * @throws ValidationError When response is malformed
-             */
-            getData: async (sectionsUid) => {
-                const response = await this.sections.get(sectionsUid);
-                return response.data;
-            },
-            /**
-             * Create section (data only)
-             * @description Returns only the data from section creation response
-             * @param request Section creation data
-             * @returns Created section information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             */
-            createData: async (request) => {
-                const response = await this.sections.create(request);
-                return response.data;
-            },
-            /**
-             * Update section (data only)
-             * @description Returns only the data from section update response
-             * @param sectionsUid Section unique identifier
-             * @param request Section update data
-             * @returns Updated section information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             */
-            updateData: async (sectionsUid, request) => {
-                const response = await this.sections.update(sectionsUid, request);
-                return response.data;
-            },
-            /**
-             * Enable/disable section (data only)
-             * @description Returns only the data from section status change response
-             * @param sectionsUid Section unique identifier
-             * @param request Status change request
-             * @returns Updated section information (data only)
-             * @throws ValidationError When request is invalid or response is malformed
-             */
-            enableData: async (sectionsUid, request) => {
-                const response = await this.sections.enable(sectionsUid, request);
-                return response.data;
-            },
-        };
-        this.healthCheckData = {
-            get: async () => {
-                const response = await this.healthCheck.get();
-                return response.data;
-            },
-        };
-        this.pingData = {
-            get: async () => {
-                const response = await this.ping.get();
-                return response.data;
-            },
+        // Create a wrapper function that calls executeRequest dynamically
+        // This allows tests to spy on executeRequest after construction
+        // Pass params when defined OR when there's a paramsSchema (for validation)
+        // Note: Resources build URLs directly, so pathParams is not used
+        const boundExecuteRequest = (config, params, pathParams) => {
+            // Pass params if defined or if there's a paramsSchema (expects params)
+            if (params !== undefined || config.paramsSchema !== undefined) {
+                return this.executeRequest(config, params, pathParams);
+            }
+            return this.executeRequest(config, undefined, pathParams);
         };
+        // Initialize standard API resources
+        this.healthCheck = (0, resources_1.createHealthCheckResource)(boundExecuteRequest);
+        this.ping = (0, resources_1.createPingResource)(boundExecuteRequest);
+        this.warehouse = (0, resources_1.createWarehouseResource)(boundExecuteRequest);
+        this.distributors = (0, resources_1.createDistributorsResource)(boundExecuteRequest);
+        this.products = (0, resources_1.createProductsResource)(boundExecuteRequest);
+        this.invProfileHdr = (0, resources_1.createInvProfileHdrResource)(boundExecuteRequest);
+        this.restockHdr = (0, resources_1.createRestockHdrResource)(boundExecuteRequest);
+        this.sections = (0, resources_1.createSectionsResource)(boundExecuteRequest);
+        // Initialize data-only API resources (dual API pattern)
+        this.healthCheckData = (0, resources_1.createHealthCheckDataResource)(this.healthCheck);
+        this.pingData = (0, resources_1.createPingDataResource)(this.ping);
+        this.warehouseData = (0, resources_1.createWarehouseDataResource)(this.warehouse);
+        this.distributorsData = (0, resources_1.createDistributorsDataResource)(this.distributors);
+        this.productsData = (0, resources_1.createProductsDataResource)(this.products);
+        this.invProfileHdrData = (0, resources_1.createInvProfileHdrDataResource)(this.invProfileHdr);
+        this.restockHdrData = (0, resources_1.createRestockHdrDataResource)(this.restockHdr);
+        this.sectionsData = (0, resources_1.createSectionsDataResource)(this.sections);
     }
 }
 exports.VMIClient = VMIClient;