@simpleapps-com/augur-api 0.3.3 → 0.4.0

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

@@ -31,10 +31,10 @@ WarehouseUserListParamsSchema, WarehouseUserListResponseSchema, CreateWarehouseU
  * const vmi = new VMIClient(http);
  *
  * // List warehouses
- * const warehouses = await vmi.warehouses.list({ customerId: 12345 });
+ * const warehouses = await vmi.warehouse.list({ customerId: 12345 });
  *
  * // Check inventory availability
- * const inventory = await vmi.inventory.checkAvailability(123, { q: 'wire' });
+ * const inventory = await vmi.warehouse.availability.get(123, { q: 'wire' });
  * ```
  */
 export class VMIClient extends BaseServiceClient {
@@ -79,7 +79,7 @@ export class VMIClient extends BaseServiceClient {
          * Warehouse management endpoints
          * @description Methods for CRUD operations on warehouses and warehouse configuration
          */
-        this.warehouses = {
+        this.warehouse = {
             /**
              * List warehouses with filtering and pagination
              * @description Returns warehouses with optional filtering by customer, user access, and status
@@ -195,7 +195,7 @@ export class VMIClient extends BaseServiceClient {
             // Data-only methods for warehouses
             /**
              * List warehouses (data only)
-             * @fullPath api.vmi.warehouses.listData
+             * @fullPath api.vmi.warehouse.listData
              * @service vmi
              * @domain warehouse-management
              * @dataMethod Standard method: warehouses.list
@@ -221,12 +221,12 @@ export class VMIClient extends BaseServiceClient {
              * ```
              */
             listData: async (params) => {
-                const response = await this.warehouses.list(params);
+                const response = await this.warehouse.list(params);
                 return response.data;
             },
             /**
              * Get warehouse details (data only)
-             * @fullPath api.vmi.warehouses.getData
+             * @fullPath api.vmi.warehouse.getData
              * @service vmi
              * @domain warehouse-management
              * @dataMethod Standard method: warehouses.get
@@ -245,12 +245,12 @@ export class VMIClient extends BaseServiceClient {
              * ```
              */
             getData: async (warehouseUid) => {
-                const response = await this.warehouses.get(warehouseUid);
+                const response = await this.warehouse.get(warehouseUid);
                 return response.data;
             },
             /**
              * Create warehouse (data only)
-             * @fullPath api.vmi.warehouses.createData
+             * @fullPath api.vmi.warehouse.createData
              * @service vmi
              * @domain warehouse-management
              * @dataMethod Standard method: warehouses.create
@@ -272,12 +272,12 @@ export class VMIClient extends BaseServiceClient {
              * ```
              */
             createData: async (request) => {
-                const response = await this.warehouses.create(request);
+                const response = await this.warehouse.create(request);
                 return response.data;
             },
             /**
              * Update warehouse (data only)
-             * @fullPath api.vmi.warehouses.updateData
+             * @fullPath api.vmi.warehouse.updateData
              * @service vmi
              * @domain warehouse-management
              * @dataMethod Standard method: warehouses.update
@@ -299,12 +299,12 @@ export class VMIClient extends BaseServiceClient {
              * ```
              */
             updateData: async (warehouseUid, request) => {
-                const response = await this.warehouses.update(warehouseUid, request);
+                const response = await this.warehouse.update(warehouseUid, request);
                 return response.data;
             },
             /**
              * Enable/disable warehouse (data only)
-             * @fullPath api.vmi.warehouses.enableData
+             * @fullPath api.vmi.warehouse.enableData
              * @service vmi
              * @domain warehouse-management
              * @dataMethod Standard method: warehouses.enable
@@ -324,288 +324,400 @@ export class VMIClient extends BaseServiceClient {
              * ```
              */
             enableData: async (warehouseUid, request) => {
-                const response = await this.warehouses.enable(warehouseUid, request);
+                const response = await this.warehouse.enable(warehouseUid, request);
                 return response.data;
             },
-        };
-        /**
-         * Inventory operation endpoints
-         * @description Methods for inventory management including availability, adjustments, receiving, and usage tracking
-         */
-        this.inventory = {
             /**
-             * Check inventory availability with search
-             * @description Searches inventory items in a warehouse with query string matching
-             * @param warehouseUid Warehouse unique identifier
-             * @param params Search parameters including required query string
-             * @returns Array of available inventory items matching search criteria
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const items = await client.inventory.checkAvailability(123, { q: 'wire' });
-             * items.forEach(item => {
-             *   console.log(`${item.item_id}: ${item.qty_on_hand} ${item.default_selling_unit}`);
-             * });
-             * ```
+             * Warehouse availability endpoints
+             * @description Methods for checking inventory availability in warehouses
              */
-            checkAvailability: async (warehouseUid, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/warehouse/{id}/availability',
-                    paramsSchema: InventoryAvailabilityParamsSchema,
-                    responseSchema: InventoryAvailabilityResponseSchema,
-                }, params, { id: String(warehouseUid) });
-            },
-            /**
-             * Adjust inventory quantities
-             * @description Sets absolute inventory quantities (not relative changes) with optional reason tracking
-             * @param warehouseUid Warehouse unique identifier
-             * @param request Adjustment request containing array of inventory adjustments
-             * @returns Success response
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * await client.inventory.adjust(123, {
-             *   adjustments: [
-             *     {
-             *       inv_mast_uid: 456,
-             *       qty_on_hand: 200.0,
-             *       reason: 'Physical count adjustment'
-             *     },
-             *     {
-             *       inv_mast_uid: 789,
-             *       qty_on_hand: 150.0,
-             *       reason: 'Damage correction'
-             *     }
-             *   ]
-             * });
-             * ```
-             */
-            adjust: async (warehouseUid, request) => {
-                await this.executeRequest({
-                    method: 'POST',
-                    path: '/warehouse/{id}/adjust',
-                    paramsSchema: InventoryAdjustRequestSchema,
-                    responseSchema: z.boolean(),
-                }, request, { id: String(warehouseUid) });
-                return true;
-            },
-            /**
-             * Receive inventory into warehouse
-             * @description Records received inventory with optional purchase order and lot tracking
-             * @param warehouseUid Warehouse unique identifier
-             * @param request Receive request containing array of inventory receipts
-             * @returns Success response
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * await client.inventory.receive(123, {
-             *   receipts: [
-             *     {
-             *       inv_mast_uid: 456,
-             *       qty_received: 50.0,
-             *       po_number: 'PO-2024-001',
-             *       lot_number: 'LOT-456'
-             *     }
-             *   ]
-             * });
-             * ```
-             */
-            receive: async (warehouseUid, request) => {
-                await this.executeRequest({
-                    method: 'POST',
-                    path: '/warehouse/{id}/receive',
-                    paramsSchema: InventoryReceiveRequestSchema,
-                    responseSchema: z.boolean(),
-                }, request, { id: String(warehouseUid) });
-                return true;
+            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.item_id}: ${item.qty_on_hand} ${item.default_selling_unit}`);
+                 * });
+                 * ```
+                 */
+                get: async (warehouseUid, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/warehouse/{id}/availability',
+                        paramsSchema: InventoryAvailabilityParamsSchema,
+                        responseSchema: InventoryAvailabilityResponseSchema,
+                    }, params, { id: 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;
+                },
             },
             /**
-             * Get replenishment information
-             * @description Returns items that need replenishment based on min/max quantities
-             * @param warehouseUid Warehouse unique identifier
-             * @param params Optional filtering by distributor
-             * @returns Replenishment information with suggested order quantities
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const replenishment = await client.inventory.getReplenishmentInfo(123, { distributorsUid: 789 });
-             * replenishment.replenishment_items.forEach(item => {
-             *   console.log(`${item.item_id}: Need ${item.suggested_order_qty} (current: ${item.qty_on_hand})`);
-             * });
-             * ```
+             * Warehouse adjust endpoints
+             * @description Methods for adjusting inventory quantities
              */
-            getReplenishmentInfo: async (warehouseUid, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/warehouse/{id}/replenish',
-                    paramsSchema: ReplenishmentParamsSchema,
-                    responseSchema: ReplenishmentInfoResponseSchema,
-                }, params, { id: String(warehouseUid) });
+            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: [
+                 *     {
+                 *       inv_mast_uid: 456,
+                 *       qty_on_hand: 200.0,
+                 *       reason: 'Physical count adjustment'
+                 *     },
+                 *     {
+                 *       inv_mast_uid: 789,
+                 *       qty_on_hand: 150.0,
+                 *       reason: 'Damage correction'
+                 *     }
+                 *   ]
+                 * });
+                 * ```
+                 */
+                create: async (warehouseUid, request) => {
+                    await this.executeRequest({
+                        method: 'POST',
+                        path: '/warehouse/{id}/adjust',
+                        paramsSchema: InventoryAdjustRequestSchema,
+                        responseSchema: z.boolean(),
+                    }, request, { id: String(warehouseUid) });
+                    return true;
+                },
             },
             /**
-             * Execute inventory replenishment
-             * @description Places replenishment orders based on min/max/reorder quantities
-             * @param warehouseUid Warehouse unique identifier
-             * @param request Replenishment request with distributor and items to restock
-             * @returns Success response
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * await client.inventory.replenish(123, {
-             *   distributor_uid: 789,
-             *   restock_items: [
-             *     { inv_mast_uid: 456, qty_to_order: 100.0 },
-             *     { inv_mast_uid: 789, qty_to_order: 75.0 }
-             *   ]
-             * });
-             * ```
+             * Warehouse receive endpoints
+             * @description Methods for receiving inventory into warehouses
              */
-            replenish: async (warehouseUid, request) => {
-                await this.executeRequest({
-                    method: 'POST',
-                    path: '/warehouse/{id}/replenish',
-                    paramsSchema: ReplenishRequestSchema,
-                    responseSchema: z.boolean(),
-                }, request, { id: String(warehouseUid) });
-                return true;
+            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: [
+                 *     {
+                 *       inv_mast_uid: 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/{id}/receive',
+                        paramsSchema: InventoryReceiveRequestSchema,
+                        responseSchema: z.boolean(),
+                    }, request, { id: String(warehouseUid) });
+                    return true;
+                },
             },
             /**
-             * Transfer inventory between warehouses
-             * @description Moves inventory from one warehouse to another with quantity tracking
-             * @param warehouseUid Source warehouse unique identifier
-             * @param request Transfer request with destination warehouse and items to transfer
-             * @returns Success response
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * await client.inventory.transfer(123, {
-             *   to_warehouse_uid: 124,
-             *   transfers: [
-             *     {
-             *       inv_mast_uid: 456,
-             *       qty_to_transfer: 25.0,
-             *       reason: 'Stock balancing'
-             *     }
-             *   ]
-             * });
-             * ```
+             * Warehouse replenish endpoints
+             * @description Methods for warehouse replenishment operations
              */
-            transfer: async (warehouseUid, request) => {
-                await this.executeRequest({
-                    method: 'POST',
-                    path: '/warehouse/{id}/transfer',
-                    paramsSchema: TransferRequestSchema,
-                    responseSchema: z.boolean(),
-                }, request, { id: String(warehouseUid) });
-                return true;
+            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.item_id}: Need ${item.suggested_order_qty} (current: ${item.qty_on_hand})`);
+                 * });
+                 * ```
+                 */
+                get: async (warehouseUid, params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/warehouse/{id}/replenish',
+                        paramsSchema: ReplenishmentParamsSchema,
+                        responseSchema: ReplenishmentInfoResponseSchema,
+                    }, params, { id: String(warehouseUid) });
+                },
+                /**
+                 * Execute inventory replenishment
+                 * @description Places replenishment orders based on min/max/reorder quantities
+                 * @param warehouseUid Warehouse unique identifier
+                 * @param request Replenishment request with distributor and items to restock
+                 * @returns Success response
+                 * @throws ValidationError When request is invalid or response is malformed
+                 * @example
+                 * ```typescript
+                 * await client.warehouse.replenish.create(123, {
+                 *   distributor_uid: 789,
+                 *   restock_items: [
+                 *     { inv_mast_uid: 456, qty_to_order: 100.0 },
+                 *     { inv_mast_uid: 789, qty_to_order: 75.0 }
+                 *   ]
+                 * });
+                 * ```
+                 */
+                create: async (warehouseUid, request) => {
+                    await this.executeRequest({
+                        method: 'POST',
+                        path: '/warehouse/{id}/replenish',
+                        paramsSchema: ReplenishRequestSchema,
+                        responseSchema: z.boolean(),
+                    }, request, { id: 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;
+                },
             },
             /**
-             * Record inventory usage
-             * @description Automatically decrements inventory and creates usage records for job tracking
-             * @param warehouseUid Warehouse unique identifier
-             * @param request Usage request with job information and consumed items
-             * @returns Success response
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * await client.inventory.recordUsage(123, {
-             *   job_description: 'Office Renovation - Building A',
-             *   department: 'Facilities',
-             *   usage_items: [
-             *     {
-             *       inv_mast_uid: 456,
-             *       inv_profile_line_type: 'prophet21',
-             *       qty_used: 5.0
-             *     },
-             *     {
-             *       inv_mast_uid: 789,
-             *       inv_profile_line_type: 'products',
-             *       qty_used: 2.0,
-             *       warranty: {
-             *         model_no: 'MDL-123',
-             *         serial_no: 'SN-456789',
-             *         warranty_type: 'Standard',
-             *         notes: 'Installed in conference room'
-             *       }
-             *     }
-             *   ]
-             * });
-             * ```
+             * Warehouse transfer endpoints
+             * @description Methods for transferring inventory between warehouses
              */
-            recordUsage: async (warehouseUid, request) => {
-                await this.executeRequest({
-                    method: 'POST',
-                    path: '/warehouse/{id}/usage',
-                    paramsSchema: UsageRequestSchema,
-                    responseSchema: z.boolean(),
-                }, request, { id: String(warehouseUid) });
-                return true;
+            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, {
+                 *   to_warehouse_uid: 124,
+                 *   transfers: [
+                 *     {
+                 *       inv_mast_uid: 456,
+                 *       qty_to_transfer: 25.0,
+                 *       reason: 'Stock balancing'
+                 *     }
+                 *   ]
+                 * });
+                 * ```
+                 */
+                create: async (warehouseUid, request) => {
+                    await this.executeRequest({
+                        method: 'POST',
+                        path: '/warehouse/{id}/transfer',
+                        paramsSchema: TransferRequestSchema,
+                        responseSchema: z.boolean(),
+                    }, request, { id: String(warehouseUid) });
+                    return true;
+                },
             },
-            // Data-only methods for inventory operations
             /**
-             * Check inventory availability (data only)
-             * @fullPath api.vmi.inventory.checkAvailabilityData
-             * @service vmi
-             * @domain inventory-management
-             * @dataMethod Standard method: inventory.checkAvailability
-             * @discoverable true
-             * @searchTerms ["inventory", "availability", "stock-check", "item-search"]
-             * @relatedEndpoints ["api.items.products.list", "api.legacy.inventory.list", "api.vmi.inventory.adjust"]
-             * @commonPatterns ["Check stock levels", "Search inventory", "Find available items"]
-             * @workflow ["inventory-lookup", "stock-verification", "item-availability-check"]
-             * @prerequisites ["Valid authentication token", "Warehouse access permissions"]
-             * @nextSteps ["api.vmi.inventory.adjust for quantity changes", "api.vmi.inventory.recordUsage for consumption"]
-             * @businessRules ["Returns only items matching search query", "Requires warehouse access permissions"]
-             * @functionalArea "inventory-and-stock-management"
-             * @caching "Real-time data, do not cache"
-             * @performance "Use specific search terms to limit results"
-             * @description Returns only the data array from inventory availability response
-             * @param warehouseUid Warehouse unique identifier
-             * @param params Search parameters including query string
-             * @returns Array of available inventory items (data only)
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const items = await client.inventory.checkAvailabilityData(123, { q: 'wire' });
-             * console.log(items); // Direct array access
-             * ```
+             * Warehouse usage endpoints
+             * @description Methods for recording inventory usage
              */
-            checkAvailabilityData: async (warehouseUid, params) => {
-                const response = await this.inventory.checkAvailability(warehouseUid, params);
-                return response.data;
+            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: [
+                 *     {
+                 *       inv_mast_uid: 456,
+                 *       inv_profile_line_type: 'prophet21',
+                 *       qty_used: 5.0
+                 *     },
+                 *     {
+                 *       inv_mast_uid: 789,
+                 *       inv_profile_line_type: 'products',
+                 *       qty_used: 2.0,
+                 *       warranty: {
+                 *         model_no: 'MDL-123',
+                 *         serial_no: 'SN-456789',
+                 *         warranty_type: 'Standard',
+                 *         notes: 'Installed in conference room'
+                 *       }
+                 *     }
+                 *   ]
+                 * });
+                 * ```
+                 */
+                create: async (warehouseUid, request) => {
+                    await this.executeRequest({
+                        method: 'POST',
+                        path: '/warehouse/{id}/usage',
+                        paramsSchema: UsageRequestSchema,
+                        responseSchema: z.boolean(),
+                    }, request, { id: String(warehouseUid) });
+                    return true;
+                },
             },
             /**
-             * Get replenishment information (data only)
-             * @fullPath api.vmi.inventory.getReplenishmentInfoData
-             * @service vmi
-             * @domain inventory-management
-             * @dataMethod Standard method: inventory.getReplenishmentInfo
-             * @discoverable true
-             * @searchTerms ["replenishment", "restock", "min-max", "reorder-points"]
-             * @relatedEndpoints ["api.vmi.inventory.replenish", "api.vmi.inventoryProfiles.lines.list"]
-             * @commonPatterns ["Check restock needs", "Get replenishment suggestions", "Find low inventory"]
-             * @workflow ["replenishment-planning", "inventory-optimization", "stock-level-monitoring"]
-             * @prerequisites ["Valid authentication token", "Warehouse access permissions", "Inventory profiles configured"]
-             * @nextSteps ["api.vmi.inventory.replenish to execute restocking", "api.vmi.inventory.adjust for manual corrections"]
-             * @businessRules ["Based on min/max quantities from inventory profiles", "Considers current stock levels and demand"]
-             * @functionalArea "inventory-and-replenishment-management"
-             * @caching "Cache for 5 minutes, invalidate on inventory changes"
-             * @performance "May be slow for large inventories, consider filtering by distributor"
-             * @description Returns only the data from replenishment information response
-             * @param warehouseUid Warehouse unique identifier
-             * @param params Optional filtering by distributor
-             * @returns Replenishment information with suggested quantities (data only)
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const replenish = await client.inventory.getReplenishmentInfoData(123);
-             * console.log(replenish.replenishment_items); // Direct access to restock suggestions
-             * ```
+             * Warehouse users endpoints
+             * @description Methods for managing user access permissions to warehouses
              */
-            getReplenishmentInfoData: async (warehouseUid, params) => {
-                const response = await this.inventory.getReplenishmentInfo(warehouseUid, params);
-                return response.data;
+            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/{id}/users',
+                        paramsSchema: WarehouseUserListParamsSchema,
+                        responseSchema: WarehouseUserListResponseSchema,
+                    }, params, { id: String(warehouseUid) });
+                },
+                /**
+                 * Create or update warehouse user access
+                 * @description Grants or updates user access to a warehouse with optional primary user designation
+                 * @param warehouseUid Warehouse unique identifier
+                 * @param request User access request data
+                 * @returns Created or updated warehouse user access information
+                 * @throws ValidationError When request is invalid or response is malformed
+                 * @example
+                 * ```typescript
+                 * // Grant standard access
+                 * const access = await client.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/{id}/users',
+                        paramsSchema: CreateWarehouseUserRequestSchema,
+                        responseSchema: WarehouseUserResponseSchema,
+                    }, request, { id: 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;
+                },
             },
         };
         /**
@@ -843,6 +955,50 @@ export class VMIClient extends BaseServiceClient {
                 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',
+                 *   distributors_uid: 789,
+                 *   customer_id: 12345
+                 * });
+                 * ```
+                 */
+                create: async (distributorsUid, request) => {
+                    return this.executeRequest({
+                        method: 'POST',
+                        path: '/distributors/{id}/products',
+                        paramsSchema: CreateProductRequestSchema,
+                        responseSchema: ProductResponseSchema,
+                    }, request, { id: 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
@@ -867,30 +1023,60 @@ export class VMIClient extends BaseServiceClient {
              */
             list: this.createListMethod('/products', ProductListParamsSchema, ProductListResponseSchema),
             /**
-             * Search across both VMI products and Prophet 21 items
-             * @description Searches both VMI custom products and Prophet 21 items with prefix matching
-             * @param params Search parameters with customer ID and optional prefix filter
-             * @returns Array of found items with type indicator (limited to 10 results)
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const items = await client.products.find({
-             *   customerId: 12345,
-             *   prefix: 'WIRE'
-             * });
-             *
-             * items.forEach(item => {
-             *   console.log(`${item.item_id} (${item.type}): ${item.description}`);
-             * });
-             * ```
+             * Products find endpoints
+             * @description Methods for searching products across VMI and Prophet 21
              */
-            find: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/products/find',
-                    paramsSchema: ProductFindParamsSchema,
-                    responseSchema: ProductFindResponseSchema,
-                }, params);
+            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.item_id} (${item.type}): ${item.description}`);
+                 * });
+                 * ```
+                 */
+                get: async (params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/products/find',
+                        paramsSchema: ProductFindParamsSchema,
+                        responseSchema: 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
@@ -954,32 +1140,6 @@ export class VMIClient extends BaseServiceClient {
                     responseSchema: ProductResponseSchema,
                 }, request, { id: String(productsUid) });
             },
-            /**
-             * Create product associated with distributor
-             * @description Creates a new product and associates it with a distributor
-             * @param distributorsUid Distributor unique identifier
-             * @param request Product creation data
-             * @returns Created product information
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * const product = await client.products.createForDistributor(789, {
-             *   product_id: 'PROD-001',
-             *   product_name: 'New Product',
-             *   product_desc: 'Product description',
-             *   distributors_uid: 789,
-             *   customer_id: 12345
-             * });
-             * ```
-             */
-            createForDistributor: async (distributorsUid, request) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/distributors/{id}/products',
-                    paramsSchema: CreateProductRequestSchema,
-                    responseSchema: ProductResponseSchema,
-                }, request, { id: String(distributorsUid) });
-            },
             // Data-only methods for products
             /**
              * List products (data only)
@@ -1005,30 +1165,6 @@ export class VMIClient extends BaseServiceClient {
                 const response = await this.products.list(params);
                 return response.data;
             },
-            /**
-             * Find products and items (data only)
-             * @fullPath api.vmi.products.findData
-             * @service vmi
-             * @domain product-management
-             * @dataMethod Standard method: products.find
-             * @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.findData({ customerId: 12345, prefix: 'WIRE' });
-             * console.log(items); // Direct array access
-             * ```
-             */
-            findData: async (params) => {
-                const response = await this.products.find(params);
-                return response.data;
-            },
             /**
              * Get product details (data only)
              * @fullPath api.vmi.products.getData
@@ -1060,132 +1196,126 @@ export class VMIClient extends BaseServiceClient {
          */
         this.invProfileHdr = {
             /**
-             * Inventory profile headers sub-endpoints
-             * @description Methods for managing inventory profile headers (containers for profile lines)
+             * 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})`);
+             * });
+             * ```
              */
-            headers: {
-                /**
-                 * List inventory profile headers
-                 * @description Returns inventory profile headers for a customer with pagination
-                 * @param params Filtering and pagination parameters (customerId is required)
-                 * @returns Array of inventory profile header objects
-                 * @throws ValidationError When parameters are invalid or response is malformed
-                 * @example
-                 * ```typescript
-                 * const headers = await client.invProfileHdr.headers.list({ customerId: 12345 });
-                 * headers.forEach(header => {
-                 *   console.log(`${header.inv_profile_hdr_desc} (ID: ${header.inv_profile_hdr_uid})`);
-                 * });
-                 * ```
-                 */
-                list: this.createListMethod('/inv-profile-hdr', InvProfileHdrListParamsSchema, 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.headers.get(1);
-                 * console.log(header.inv_profile_hdr_desc);
-                 * ```
-                 */
-                get: this.createGetMethod('/inv-profile-hdr/{id}', 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.headers.create({
-                 *   inv_profile_hdr_desc: 'Standard Office Setup Profile',
-                 *   customer_id: 12345
-                 * });
-                 * ```
-                 */
-                create: this.createCreateMethod('/inv-profile-hdr', CreateInvProfileHdrRequestSchema, 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.headers.update(1, {
-                 *   inv_profile_hdr_desc: 'Updated Profile Description'
-                 * });
-                 * ```
-                 */
-                update: this.createUpdateMethod('/inv-profile-hdr/{id}', UpdateInvProfileHdrRequestSchema, 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.headers.delete(1);
-                 * ```
-                 */
-                delete: this.createDeleteBooleanMethod('/inv-profile-hdr/{id}'),
-                // 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.headers.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.headers.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.headers.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.headers.update(invProfileHdrUid, request);
-                    return response.data;
-                },
+            list: this.createListMethod('/inv-profile-hdr', InvProfileHdrListParamsSchema, 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.inv_profile_hdr_desc);
+             * ```
+             */
+            get: this.createGetMethod('/inv-profile-hdr/{id}', 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({
+             *   inv_profile_hdr_desc: 'Standard Office Setup Profile',
+             *   customer_id: 12345
+             * });
+             * ```
+             */
+            create: this.createCreateMethod('/inv-profile-hdr', CreateInvProfileHdrRequestSchema, 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, {
+             *   inv_profile_hdr_desc: 'Updated Profile Description'
+             * });
+             * ```
+             */
+            update: this.createUpdateMethod('/inv-profile-hdr/{id}', UpdateInvProfileHdrRequestSchema, 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/{id}'),
+            // 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)
              */
-            lines: {
+            invProfileLine: {
                 /**
                  * List inventory profile lines for a header
                  * @description Returns inventory profile lines within a specific header with pagination
@@ -1195,7 +1325,7 @@ export class VMIClient extends BaseServiceClient {
                  * @throws ValidationError When parameters are invalid or response is malformed
                  * @example
                  * ```typescript
-                 * const lines = await client.invProfileHdr.lines.list(1, { limit: 20 });
+                 * const lines = await client.invProfileHdr.invProfileLine.list(1, { limit: 20 });
                  * lines.forEach(line => {
                  *   console.log(`Item ${line.inv_mast_uid}: Min ${line.min_qty}, Max ${line.max_qty}`);
                  * });
@@ -1218,7 +1348,7 @@ export class VMIClient extends BaseServiceClient {
                  * @throws ValidationError When response is malformed
                  * @example
                  * ```typescript
-                 * const line = await client.invProfileHdr.lines.get(1, 10);
+                 * const line = await client.invProfileHdr.invProfileLine.get(1, 10);
                  * console.log(`${line.inv_profile_line_type}: ${line.min_qty}-${line.max_qty}`);
                  * ```
                  */
@@ -1238,7 +1368,7 @@ export class VMIClient extends BaseServiceClient {
                  * @throws ValidationError When request is invalid or response is malformed
                  * @example
                  * ```typescript
-                 * const line = await client.invProfileHdr.lines.create(1, {
+                 * const line = await client.invProfileHdr.invProfileLine.create(1, {
                  *   inv_mast_uid: 456,
                  *   inv_profile_line_type: 'prophet21',
                  *   min_qty: 50.0,
@@ -1265,7 +1395,7 @@ export class VMIClient extends BaseServiceClient {
                  * @throws ValidationError When request is invalid or response is malformed
                  * @example
                  * ```typescript
-                 * const updated = await client.invProfileHdr.lines.update(1, 10, {
+                 * const updated = await client.invProfileHdr.invProfileLine.update(1, 10, {
                  *   min_qty: 75.0,
                  *   max_qty: 250.0
                  * });
@@ -1288,7 +1418,7 @@ export class VMIClient extends BaseServiceClient {
                  * @throws ValidationError When response is malformed
                  * @example
                  * ```typescript
-                 * const deleted = await client.invProfileHdr.lines.delete(1, 10);
+                 * const deleted = await client.invProfileHdr.invProfileLine.delete(1, 10);
                  * ```
                  */
                 delete: async (invProfileHdrUid, invProfileLineUid) => {
@@ -1309,7 +1439,7 @@ export class VMIClient extends BaseServiceClient {
                  * @throws ValidationError When parameters are invalid or response is malformed
                  */
                 listData: async (invProfileHdrUid, params) => {
-                    const response = await this.invProfileHdr.lines.list(invProfileHdrUid, params);
+                    const response = await this.invProfileHdr.invProfileLine.list(invProfileHdrUid, params);
                     return response.data;
                 },
                 /**
@@ -1321,7 +1451,7 @@ export class VMIClient extends BaseServiceClient {
                  * @throws ValidationError When response is malformed
                  */
                 getData: async (invProfileHdrUid, invProfileLineUid) => {
-                    const response = await this.invProfileHdr.lines.get(invProfileHdrUid, invProfileLineUid);
+                    const response = await this.invProfileHdr.invProfileLine.get(invProfileHdrUid, invProfileLineUid);
                     return response.data;
                 },
                 /**
@@ -1333,7 +1463,7 @@ export class VMIClient extends BaseServiceClient {
                  * @throws ValidationError When request is invalid or response is malformed
                  */
                 createData: async (invProfileHdrUid, request) => {
-                    const response = await this.invProfileHdr.lines.create(invProfileHdrUid, request);
+                    const response = await this.invProfileHdr.invProfileLine.create(invProfileHdrUid, request);
                     return response.data;
                 },
                 /**
@@ -1346,7 +1476,7 @@ export class VMIClient extends BaseServiceClient {
                  * @throws ValidationError When request is invalid or response is malformed
                  */
                 updateData: async (invProfileHdrUid, invProfileLineUid, request) => {
-                    const response = await this.invProfileHdr.lines.update(invProfileHdrUid, invProfileLineUid, request);
+                    const response = await this.invProfileHdr.invProfileLine.update(invProfileHdrUid, invProfileLineUid, request);
                     return response.data;
                 },
             },
@@ -1630,90 +1760,6 @@ export class VMIClient extends BaseServiceClient {
                 return response.data;
             },
         };
-        /**
-         * User access management endpoints
-         * @description Methods for managing user access permissions to warehouses
-         */
-        this.userAccess = {
-            /**
-             * List users with access to specific warehouse
-             * @description Returns users who have access to a warehouse with optional status filtering
-             * @param warehouseUid Warehouse unique identifier
-             * @param params Optional filtering and pagination parameters
-             * @returns Array of warehouse user access records
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * const users = await client.userAccess.listWarehouseUsers(123, { limit: 20 });
-             * users.forEach(user => {
-             *   console.log(`User ${user.users_id} - Status: ${user.status_cd}`);
-             * });
-             * ```
-             */
-            listWarehouseUsers: async (warehouseUid, params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/warehouse/{id}/users',
-                    paramsSchema: WarehouseUserListParamsSchema,
-                    responseSchema: WarehouseUserListResponseSchema,
-                }, params, { id: String(warehouseUid) });
-            },
-            /**
-             * Create or update warehouse user access
-             * @description Grants or updates user access to a warehouse with optional primary user designation
-             * @param warehouseUid Warehouse unique identifier
-             * @param request User access request data
-             * @returns Created or updated warehouse user access information
-             * @throws ValidationError When request is invalid or response is malformed
-             * @example
-             * ```typescript
-             * // Grant standard access
-             * const access = await client.userAccess.createWarehouseUser(123, {
-             *   users_id: 456,
-             *   status_cd: 704
-             * });
-             *
-             * // Grant access
-             * const access2 = await client.userAccess.createWarehouseUser(123, {
-             *   users_id: 456,
-             *   status_cd: 704
-             * });
-             * ```
-             */
-            createWarehouseUser: async (warehouseUid, request) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/warehouse/{id}/users',
-                    paramsSchema: CreateWarehouseUserRequestSchema,
-                    responseSchema: WarehouseUserResponseSchema,
-                }, request, { id: String(warehouseUid) });
-            },
-            // Data-only methods for user access
-            /**
-             * 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
-             */
-            listWarehouseUsersData: async (warehouseUid, params) => {
-                const response = await this.userAccess.listWarehouseUsers(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
-             */
-            createWarehouseUserData: async (warehouseUid, request) => {
-                const response = await this.userAccess.createWarehouseUser(warehouseUid, request);
-                return response;
-            },
-        };
         /**
          * Health Data Operations
          * @description Direct access to health check data without response metadata