@simpleapps-com/augur-api 0.3.3 → 0.4.0

package/dist/cjs/services/p21-sism/client.js

@@ -34,20 +34,20 @@ const schemas_2 = require("./schemas");
  * const client = new P21SismClient(new HTTPClient({ baseURL: 'https://p21-sism.augur-api.com' }));
  *
  * // List recent imports for monitoring
- * const recentImports = await client.import.recent({ hours: 24, limit: 50 });
+ * const recentImports = await client.import.recent.list({ hours: 24, limit: 50 });
  * console.log(recentImports.data); // Import[]
  *
  * // Get import details for processing
- * const importDetails = await client.import.get({ importUid: '12345' });
+ * const importDetails = await client.import.get('12345');
  * console.log(importDetails.data); // Import
  *
  * // Process order entry header data
- * const orderHeader = await client.orderEntry.getHeader({ importUid: '12345' });
+ * const orderHeader = await client.import.impOeHdr.get('12345');
  * console.log(orderHeader.data); // Order entry header data
  *
- * // Check for stuck imports
- * const stuckImports = await client.import.stuck({ hours: 48 });
- * console.log(stuckImports.data); // Import[]
+ * // Create SFTP metadata for scheduled imports
+ * const sftpResult = await client.scheduledImportMaster.metadata.sftp.create('master123');
+ * console.log(sftpResult.data); // SFTP metadata result
  * ```
  */
 class P21SismClient extends base_client_1.BaseServiceClient {
@@ -66,6 +66,47 @@ class P21SismClient extends base_client_1.BaseServiceClient {
         this._schemaRefs = {
             ImportSchema: schemas_2.ImportSchema,
         };
+        /**
+         * Health check operations for service monitoring and system status verification
+         * @fullPath api.p21Sism.healthCheck
+         * @service p21-sism
+         * @domain system-monitoring
+         * @discoverable true
+         */
+        this.healthCheck = {
+            /**
+             * Perform health check to verify P21 SISM service status and connectivity
+             *
+             * @fullPath api.p21Sism.healthCheck.get
+             * @service p21-sism
+             * @domain system-monitoring
+             * @dataMethod getData - returns only the health status without metadata
+             * @discoverable true
+             * @searchTerms ["health check", "service status", "system monitor", "service availability", "connectivity test", "SISM health"]
+             * @relatedEndpoints ["api.p21Core.health.check", "api.p21Sism.import.recent.list", "system monitoring endpoints"]
+             * @commonPatterns ["Check service health", "Monitor system status", "Verify connectivity", "Service diagnostics"]
+             * @workflow ["system-monitoring", "health-verification", "service-diagnostics", "integration-testing"]
+             * @prerequisites ["System access", "Monitoring permissions"]
+             * @nextSteps ["Service remediation if unhealthy", "Integration health checks", "api.p21Sism.import.stuck.list for processing issues"]
+             * @businessRules ["Returns site configuration", "Includes system hash for verification", "No authentication required for health check"]
+             * @functionalArea "system-monitoring"
+             * @performance "Lightweight check, immediate response, minimal system impact"
+             *
+             * @returns Promise<BaseResponse<HealthCheckResponse>> Service health status and configuration
+             */
+            get: async () => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/health-check',
+                    responseSchema: schemas_2.HealthCheckResponseSchema,
+                });
+            },
+            // Data method for health operations
+            getData: async () => {
+                const response = await this.healthCheck.get();
+                return response.data;
+            },
+        };
         /**
          * Import management operations for data processing and system integration
          * @fullPath api.p21Sism.import
@@ -83,7 +124,7 @@ class P21SismClient extends base_client_1.BaseServiceClient {
              * @dataMethod listData - returns only the imports array without metadata
              * @discoverable true
              * @searchTerms ["imports", "data import", "import list", "batch processing", "data synchronization", "import management"]
-             * @relatedEndpoints ["api.p21Sism.import.get", "api.p21Sism.import.recent", "api.p21Sism.import.stuck"]
+             * @relatedEndpoints ["api.p21Sism.import.get", "api.p21Sism.import.recent.list", "api.p21Sism.import.stuck.list"]
              * @commonPatterns ["List all imports", "Filter imports by state", "Search import history", "Monitor import progress"]
              * @workflow ["import-monitoring", "data-management", "system-integration", "batch-processing"]
              * @prerequisites ["Valid authentication", "Import management permissions"]
@@ -110,72 +151,6 @@ class P21SismClient extends base_client_1.BaseServiceClient {
              * ```
              */
             list: this.createListMethod('/import', schemas_2.ImportListParamsSchema, UnknownArrayResponseSchema),
-            /**
-             * Get recent imports for monitoring and status tracking
-             *
-             * @fullPath api.p21Sism.import.recent
-             * @service p21-sism
-             * @domain data-import-management
-             * @dataMethod recentData - returns only the imports array without metadata
-             * @discoverable true
-             * @searchTerms ["recent imports", "import monitoring", "latest imports", "import status", "recent activity"]
-             * @relatedEndpoints ["api.p21Sism.import.list", "api.p21Sism.import.stuck", "api.p21Sism.health.check"]
-             * @commonPatterns ["Monitor recent import activity", "Check latest import status", "Track import progress"]
-             * @workflow ["import-monitoring", "status-tracking", "system-health", "operational-awareness"]
-             * @prerequisites ["Valid authentication", "Import monitoring permissions"]
-             * @nextSteps ["api.p21Sism.import.get for import details", "api.p21Sism.import.stuck to check for issues"]
-             * @businessRules ["Default 48 hours lookback", "Maximum 1000 results", "Ordered by creation date"]
-             * @functionalArea "data-import-management"
-             * @caching "Cache for 2 minutes, recent data needs freshness"
-             * @performance "Optimized query with date range filtering, minimal processing overhead"
-             *
-             * @param params Optional time range and limit parameters
-             * @returns Promise<BaseResponse<Import[]>> Complete response with recent imports
-             *
-             * @example
-             * ```typescript
-             * // Get imports from last 24 hours
-             * const response = await client.import.recent({ hours: 24, limit: 100 });
-             * console.log(response.data); // Import[]
-             *
-             * // Get just the data
-             * const recentImports = await client.import.recentData({ hours: 12 });
-             * ```
-             */
-            recent: this.createListMethod('/import/recent', schemas_2.ImportRecentParamsSchema, UnknownArrayResponseSchema),
-            /**
-             * Get stuck imports for troubleshooting and error resolution
-             *
-             * @fullPath api.p21Sism.import.stuck
-             * @service p21-sism
-             * @domain data-import-management
-             * @dataMethod stuckData - returns only the imports array without metadata
-             * @discoverable true
-             * @searchTerms ["stuck imports", "failed imports", "import errors", "import troubleshooting", "processing issues"]
-             * @relatedEndpoints ["api.p21Sism.import.recent", "api.p21Sism.import.get", "api.p21Sism.import.update"]
-             * @commonPatterns ["Troubleshoot import issues", "Find failed imports", "Monitor processing problems"]
-             * @workflow ["error-resolution", "import-troubleshooting", "system-maintenance", "issue-identification"]
-             * @prerequisites ["Valid authentication", "Import troubleshooting permissions"]
-             * @nextSteps ["api.p21Sism.import.get for error details", "api.p21Sism.import.update to retry", "api.p21Sism.import.delete to clean up"]
-             * @businessRules ["Default 48 hours lookback for stuck detection", "Maximum 1000 results", "Identifies imports in error states"]
-             * @functionalArea "data-import-management"
-             * @caching "Cache for 1 minute, error data needs immediate visibility"
-             * @performance "Specialized query for error detection, includes diagnostic information"
-             *
-             * @param params Optional time range and limit parameters
-             * @returns Promise<BaseResponse<Import[]>> Complete response with stuck imports for troubleshooting
-             *
-             * @example
-             * ```typescript
-             * // Get imports stuck in last 48 hours
-             * const response = await client.import.stuck({ hours: 48, limit: 200 });
-             * console.log(response.data); // Import[]
-             *
-             * // Get just the data
-             * const stuckImports = await client.import.stuckData({ hours: 72 });
-             * ```
-             */
-            stuck: this.createListMethod('/import/stuck', schemas_2.ImportStuckParamsSchema, UnknownArrayResponseSchema),
             /**
              * Get import details by UID for comprehensive import information
              *
@@ -185,24 +160,24 @@ class P21SismClient extends base_client_1.BaseServiceClient {
              * @dataMethod getData - returns only the import object without metadata
              * @discoverable true
              * @searchTerms ["import details", "import info", "import status", "import data", "import processing"]
-             * @relatedEndpoints ["api.p21Sism.import.list", "api.p21Sism.import.update", "api.p21Sism.orderEntry.getHeader"]
+             * @relatedEndpoints ["api.p21Sism.import.list", "api.p21Sism.import.update", "api.p21Sism.import.impOeHdr.get"]
              * @commonPatterns ["Get import status", "View import details", "Check processing results", "Retrieve import data"]
              * @workflow ["import-details", "status-checking", "data-retrieval", "import-analysis"]
              * @prerequisites ["Valid import UID", "Import access permissions"]
-             * @nextSteps ["api.p21Sism.import.update for modifications", "api.p21Sism.orderEntry for related data"]
+             * @nextSteps ["api.p21Sism.import.update for modifications", "api.p21Sism.import.impOeHdr for related data"]
              * @businessRules ["Import UID must exist", "Includes processing results and status", "Shows complete import lifecycle"]
              * @functionalArea "data-import-management"
              * @performance "Direct lookup by UID, includes all related import data"
              *
-             * @param params Import UID parameter
+             * @param importUid Import UID parameter
              * @returns Promise<BaseResponse<Import>> Complete response with detailed import information
              */
-            get: async (params) => this.executeRequest({
+            get: async (importUid) => this.executeRequest({
                 method: 'GET',
                 path: '/import/{importUid}',
                 paramsSchema: schemas_2.ImportDetailParamsSchema,
                 responseSchema: UnknownResponseSchema,
-            }, params, { importUid: params.importUid }),
+            }, { importUid }, { importUid }),
             /**
              * Update import details and processing status
              *
@@ -216,20 +191,20 @@ class P21SismClient extends base_client_1.BaseServiceClient {
              * @commonPatterns ["Update import status", "Modify import data", "Retry failed import", "Change import state"]
              * @workflow ["import-management", "status-updates", "import-processing", "error-recovery"]
              * @prerequisites ["Valid import UID", "Import modification permissions"]
-             * @nextSteps ["api.p21Sism.import.get to verify changes", "api.p21Sism.orderEntry for processing"]
+             * @nextSteps ["api.p21Sism.import.get to verify changes", "api.p21Sism.import.impOeHdr for processing"]
              * @businessRules ["State transitions must be valid", "Updates affect processing workflow", "Audit trail maintained"]
              * @functionalArea "data-import-management"
              * @performance "Immediate update with validation, triggers workflow processing"
              *
-             * @param params Import UID parameter
+             * @param importUid Import UID parameter
              * @returns Promise<BaseResponse<Import>> Complete response with updated import information
              */
-            update: async (params) => this.executeRequest({
+            update: async (importUid) => this.executeRequest({
                 method: 'PUT',
                 path: '/import/{importUid}',
                 paramsSchema: schemas_2.ImportDetailParamsSchema,
                 responseSchema: UnknownResponseSchema,
-            }, params, { importUid: params.importUid }),
+            }, { importUid }, { importUid }),
             /**
              * Clean pending import data for import cleanup and maintenance
              *
@@ -239,7 +214,7 @@ class P21SismClient extends base_client_1.BaseServiceClient {
              * @dataMethod deleteData - returns only the cleanup result without metadata
              * @discoverable true
              * @searchTerms ["delete import", "clean import", "remove import", "import cleanup", "pending import cleanup"]
-             * @relatedEndpoints ["api.p21Sism.import.get", "api.p21Sism.import.stuck", "api.p21Sism.import.list"]
+             * @relatedEndpoints ["api.p21Sism.import.get", "api.p21Sism.import.stuck.list", "api.p21Sism.import.list"]
              * @commonPatterns ["Clean up failed imports", "Remove stuck imports", "System maintenance", "Import cleanup"]
              * @workflow ["import-cleanup", "system-maintenance", "error-recovery", "data-cleanup"]
              * @prerequisites ["Valid import UID", "Import cleanup permissions", "Import in deletable state"]
@@ -248,208 +223,314 @@ class P21SismClient extends base_client_1.BaseServiceClient {
              * @functionalArea "data-import-management"
              * @performance "Cleanup operation with validation, affects related pending data"
              *
-             * @param params Import UID parameter
+             * @param importUid Import UID parameter
              * @returns Promise<BaseResponse<Import>> Complete response with cleanup confirmation
              */
-            delete: async (params) => this.executeRequest({
+            delete: async (importUid) => this.executeRequest({
                 method: 'DELETE',
                 path: '/import/{importUid}',
                 paramsSchema: schemas_2.ImportDetailParamsSchema,
                 responseSchema: UnknownResponseSchema,
-            }, params, { importUid: params.importUid }),
-            // Data methods for import operations
-            listData: async (params) => {
-                const response = await this.import.list(params);
-                return response.data;
-            },
-            recentData: async (params) => {
-                const response = await this.import.recent(params);
-                return response.data;
-            },
-            stuckData: async (params) => {
-                const response = await this.import.stuck(params);
-                return response.data;
-            },
-            getData: async (params) => {
-                const response = await this.import.get(params);
-                return response.data;
-            },
-            updateData: async (params) => {
-                const response = await this.import.update(params);
-                return response.data;
-            },
-            deleteData: async (params) => {
-                const response = await this.import.delete(params);
-                return response.data;
-            },
-        };
-        /**
-         * Order entry operations for processing order header and sales representative data
-         * @fullPath api.p21Sism.orderEntry
-         * @service p21-sism
-         * @domain order-entry-processing
-         * @discoverable true
-         */
-        this.orderEntry = {
+            }, { importUid }, { importUid }),
             /**
-             * Get order entry header details from imp_oe_hdr table
-             *
-             * @fullPath api.p21Sism.orderEntry.getHeader
+             * Recent imports operations for monitoring and status tracking
+             * @fullPath api.p21Sism.import.recent
              * @service p21-sism
-             * @domain order-entry-processing
-             * @dataMethod getHeaderData - returns only the header data without metadata
+             * @domain data-import-management
              * @discoverable true
-             * @searchTerms ["order entry header", "oe header", "order header", "import order header", "order processing"]
-             * @relatedEndpoints ["api.p21Sism.orderEntry.updateHeader", "api.p21Sism.orderEntry.getSalesrep", "api.p21Sism.import.get"]
-             * @commonPatterns ["Get order header data", "Process order entry", "Order import processing", "Header data retrieval"]
-             * @workflow ["order-entry-processing", "order-import", "header-processing", "order-management"]
-             * @prerequisites ["Valid import UID", "Order entry access permissions", "Import must contain order data"]
-             * @nextSteps ["api.p21Sism.orderEntry.updateHeader for modifications", "api.orders.orders for order processing"]
-             * @businessRules ["Import UID must reference valid order entry import", "Header data structure varies by import type", "Processing state affects data availability"]
-             * @functionalArea "order-entry-processing"
-             * @performance "Direct table access, optimized for order processing workflows"
-             *
-             * @param params Import UID parameter
-             * @returns Promise<BaseResponse<unknown>> Complete response with order entry header data
              */
-            getHeader: async (params) => this.executeRequest({
-                method: 'GET',
-                path: '/import/{importUid}/imp-oe-hdr',
-                paramsSchema: schemas_2.OrderEntryHeaderParamsSchema,
-                responseSchema: UnknownResponseSchema,
-            }, params, { importUid: params.importUid }),
+            recent: {
+                /**
+                 * Get recent imports for monitoring and status tracking
+                 *
+                 * @fullPath api.p21Sism.import.recent.list
+                 * @service p21-sism
+                 * @domain data-import-management
+                 * @dataMethod listData - returns only the imports array without metadata
+                 * @discoverable true
+                 * @searchTerms ["recent imports", "import monitoring", "latest imports", "import status", "recent activity"]
+                 * @relatedEndpoints ["api.p21Sism.import.list", "api.p21Sism.import.stuck.list", "api.p21Sism.healthCheck.get"]
+                 * @commonPatterns ["Monitor recent import activity", "Check latest import status", "Track import progress"]
+                 * @workflow ["import-monitoring", "status-tracking", "system-health", "operational-awareness"]
+                 * @prerequisites ["Valid authentication", "Import monitoring permissions"]
+                 * @nextSteps ["api.p21Sism.import.get for import details", "api.p21Sism.import.stuck.list to check for issues"]
+                 * @businessRules ["Default 48 hours lookback", "Maximum 1000 results", "Ordered by creation date"]
+                 * @functionalArea "data-import-management"
+                 * @caching "Cache for 2 minutes, recent data needs freshness"
+                 * @performance "Optimized query with date range filtering, minimal processing overhead"
+                 *
+                 * @param params Optional time range and limit parameters
+                 * @returns Promise<BaseResponse<Import[]>> Complete response with recent imports
+                 *
+                 * @example
+                 * ```typescript
+                 * // Get imports from last 24 hours
+                 * const response = await client.import.recent.list({ hours: 24, limit: 100 });
+                 * console.log(response.data); // Import[]
+                 *
+                 * // Get just the data
+                 * const recentImports = await client.import.recent.listData({ hours: 12 });
+                 * ```
+                 */
+                list: this.createListMethod('/import/recent', schemas_2.ImportRecentParamsSchema, UnknownArrayResponseSchema),
+                // Data method
+                listData: async (params) => {
+                    const response = await this.import.recent.list(params);
+                    return response.data;
+                },
+            },
             /**
-             * Update order entry header data in imp_oe_hdr table
-             *
-             * @fullPath api.p21Sism.orderEntry.updateHeader
+             * Stuck imports operations for troubleshooting and error resolution
+             * @fullPath api.p21Sism.import.stuck
              * @service p21-sism
-             * @domain order-entry-processing
-             * @dataMethod updateHeaderData - returns only the updated header data without metadata
+             * @domain data-import-management
              * @discoverable true
-             * @searchTerms ["update order header", "modify order entry", "order header update", "oe header update"]
-             * @relatedEndpoints ["api.p21Sism.orderEntry.getHeader", "api.p21Sism.orderEntry.updateSalesrep", "api.p21Sism.import.update"]
-             * @commonPatterns ["Update order header", "Modify order entry data", "Process order changes", "Header data updates"]
-             * @workflow ["order-processing", "order-modifications", "header-updates", "order-management"]
-             * @prerequisites ["Valid import UID", "Order modification permissions", "Order in editable state"]
-             * @nextSteps ["api.p21Sism.orderEntry.getHeader to verify changes", "api.orders.orders for order processing"]
-             * @businessRules ["Validation rules apply to header updates", "State transitions must be valid", "Updates affect order processing workflow"]
-             * @functionalArea "order-entry-processing"
-             * @performance "Direct table updates with validation, triggers order processing workflows"
-             *
-             * @param params Import UID parameter
-             * @returns Promise<BaseResponse<unknown>> Complete response with updated order entry header data
              */
-            updateHeader: async (params) => this.executeRequest({
-                method: 'PUT',
-                path: '/import/{importUid}/imp-oe-hdr',
-                paramsSchema: schemas_2.OrderEntryHeaderParamsSchema,
-                responseSchema: UnknownResponseSchema,
-            }, params, { importUid: params.importUid }),
+            stuck: {
+                /**
+                 * Get stuck imports for troubleshooting and error resolution
+                 *
+                 * @fullPath api.p21Sism.import.stuck.list
+                 * @service p21-sism
+                 * @domain data-import-management
+                 * @dataMethod listData - returns only the imports array without metadata
+                 * @discoverable true
+                 * @searchTerms ["stuck imports", "failed imports", "import errors", "import troubleshooting", "processing issues"]
+                 * @relatedEndpoints ["api.p21Sism.import.recent.list", "api.p21Sism.import.get", "api.p21Sism.import.update"]
+                 * @commonPatterns ["Troubleshoot import issues", "Find failed imports", "Monitor processing problems"]
+                 * @workflow ["error-resolution", "import-troubleshooting", "system-maintenance", "issue-identification"]
+                 * @prerequisites ["Valid authentication", "Import troubleshooting permissions"]
+                 * @nextSteps ["api.p21Sism.import.get for error details", "api.p21Sism.import.update to retry", "api.p21Sism.import.delete to clean up"]
+                 * @businessRules ["Default 48 hours lookback for stuck detection", "Maximum 1000 results", "Identifies imports in error states"]
+                 * @functionalArea "data-import-management"
+                 * @caching "Cache for 1 minute, error data needs immediate visibility"
+                 * @performance "Specialized query for error detection, includes diagnostic information"
+                 *
+                 * @param params Optional time range and limit parameters
+                 * @returns Promise<BaseResponse<Import[]>> Complete response with stuck imports for troubleshooting
+                 *
+                 * @example
+                 * ```typescript
+                 * // Get imports stuck in last 48 hours
+                 * const response = await client.import.stuck.list({ hours: 48, limit: 200 });
+                 * console.log(response.data); // Import[]
+                 *
+                 * // Get just the data
+                 * const stuckImports = await client.import.stuck.listData({ hours: 72 });
+                 * ```
+                 */
+                list: this.createListMethod('/import/stuck', schemas_2.ImportStuckParamsSchema, UnknownArrayResponseSchema),
+                // Data method
+                listData: async (params) => {
+                    const response = await this.import.stuck.list(params);
+                    return response.data;
+                },
+            },
             /**
-             * Get order entry sales representative details from imp_oe_hdr_salesrep table
-             *
-             * @fullPath api.p21Sism.orderEntry.getSalesrep
+             * Import order entry header operations mirroring /import/{importUid}/imp-oe-hdr path
+             * @fullPath api.p21Sism.import.impOeHdr
              * @service p21-sism
              * @domain order-entry-processing
-             * @dataMethod getSalesrepData - returns only the salesrep data without metadata
              * @discoverable true
-             * @searchTerms ["order salesrep", "sales representative", "oe salesrep", "order sales rep", "salesrep data"]
-             * @relatedEndpoints ["api.p21Sism.orderEntry.updateSalesrep", "api.p21Sism.orderEntry.getHeader", "api.orders.orders.salesrep"]
-             * @commonPatterns ["Get sales rep info", "Process salesrep data", "Order sales rep processing", "Commission processing"]
-             * @workflow ["salesrep-processing", "commission-calculation", "order-attribution", "sales-management"]
-             * @prerequisites ["Valid import UID", "Sales rep access permissions", "Import must contain salesrep data"]
-             * @nextSteps ["api.p21Sism.orderEntry.updateSalesrep for modifications", "api.orders.orders for commission processing"]
-             * @businessRules ["Sales rep assignments affect commission calculation", "Multiple sales reps per order supported", "Territory validation applies"]
-             * @functionalArea "order-entry-processing"
-             * @performance "Optimized for sales rep lookup and commission calculations"
-             *
-             * @param params Import UID parameter
-             * @returns Promise<BaseResponse<unknown>> Complete response with sales representative data
              */
-            getSalesrep: async (params) => this.executeRequest({
-                method: 'GET',
-                path: '/import/{importUid}/imp-oe-hdr-salesrep',
-                paramsSchema: schemas_2.OrderEntryHeaderSalesrepParamsSchema,
-                responseSchema: UnknownResponseSchema,
-            }, params, { importUid: params.importUid }),
+            impOeHdr: {
+                /**
+                 * Get order entry header details from imp_oe_hdr table
+                 *
+                 * @fullPath api.p21Sism.import.impOeHdr.get
+                 * @service p21-sism
+                 * @domain order-entry-processing
+                 * @dataMethod getData - returns only the header data without metadata
+                 * @discoverable true
+                 * @searchTerms ["order entry header", "oe header", "order header", "import order header", "order processing"]
+                 * @relatedEndpoints ["api.p21Sism.import.impOeHdr.update", "api.p21Sism.import.impOeHdrSalesrep.get", "api.p21Sism.import.get"]
+                 * @commonPatterns ["Get order header data", "Process order entry", "Order import processing", "Header data retrieval"]
+                 * @workflow ["order-entry-processing", "order-import", "header-processing", "order-management"]
+                 * @prerequisites ["Valid import UID", "Order entry access permissions", "Import must contain order data"]
+                 * @nextSteps ["api.p21Sism.import.impOeHdr.update for modifications", "api.orders.orders for order processing"]
+                 * @businessRules ["Import UID must reference valid order entry import", "Header data structure varies by import type", "Processing state affects data availability"]
+                 * @functionalArea "order-entry-processing"
+                 * @performance "Direct table access, optimized for order processing workflows"
+                 *
+                 * @param importUid Import UID parameter
+                 * @returns Promise<BaseResponse<unknown>> Complete response with order entry header data
+                 */
+                get: async (importUid) => this.executeRequest({
+                    method: 'GET',
+                    path: '/import/{importUid}/imp-oe-hdr',
+                    paramsSchema: schemas_2.OrderEntryHeaderParamsSchema,
+                    responseSchema: UnknownResponseSchema,
+                }, { importUid }, { importUid }),
+                /**
+                 * Update order entry header data in imp_oe_hdr table
+                 *
+                 * @fullPath api.p21Sism.import.impOeHdr.update
+                 * @service p21-sism
+                 * @domain order-entry-processing
+                 * @dataMethod updateData - returns only the updated header data without metadata
+                 * @discoverable true
+                 * @searchTerms ["update order header", "modify order entry", "order header update", "oe header update"]
+                 * @relatedEndpoints ["api.p21Sism.import.impOeHdr.get", "api.p21Sism.import.impOeHdrSalesrep.update", "api.p21Sism.import.update"]
+                 * @commonPatterns ["Update order header", "Modify order entry data", "Process order changes", "Header data updates"]
+                 * @workflow ["order-processing", "order-modifications", "header-updates", "order-management"]
+                 * @prerequisites ["Valid import UID", "Order modification permissions", "Order in editable state"]
+                 * @nextSteps ["api.p21Sism.import.impOeHdr.get to verify changes", "api.orders.orders for order processing"]
+                 * @businessRules ["Validation rules apply to header updates", "State transitions must be valid", "Updates affect order processing workflow"]
+                 * @functionalArea "order-entry-processing"
+                 * @performance "Direct table updates with validation, triggers order processing workflows"
+                 *
+                 * @param importUid Import UID parameter
+                 * @returns Promise<BaseResponse<unknown>> Complete response with updated order entry header data
+                 */
+                update: async (importUid) => this.executeRequest({
+                    method: 'PUT',
+                    path: '/import/{importUid}/imp-oe-hdr',
+                    paramsSchema: schemas_2.OrderEntryHeaderParamsSchema,
+                    responseSchema: UnknownResponseSchema,
+                }, { importUid }, { importUid }),
+                // Data methods
+                getData: async (importUid) => {
+                    const response = await this.import.impOeHdr.get(importUid);
+                    return response.data;
+                },
+                updateData: async (importUid) => {
+                    const response = await this.import.impOeHdr.update(importUid);
+                    return response.data;
+                },
+            },
             /**
-             * Update order entry sales representative data in imp_oe_hdr_salesrep table
-             *
-             * @fullPath api.p21Sism.orderEntry.updateSalesrep
+             * Import order entry header sales rep operations mirroring /import/{importUid}/imp-oe-hdr-salesrep path
+             * @fullPath api.p21Sism.import.impOeHdrSalesrep
              * @service p21-sism
              * @domain order-entry-processing
-             * @dataMethod updateSalesrepData - returns only the updated salesrep data without metadata
              * @discoverable true
-             * @searchTerms ["update salesrep", "modify sales rep", "salesrep update", "commission update", "sales rep assignment"]
-             * @relatedEndpoints ["api.p21Sism.orderEntry.getSalesrep", "api.p21Sism.orderEntry.updateHeader", "api.orders.orders.updateSalesrep"]
-             * @commonPatterns ["Update sales rep assignment", "Modify commission data", "Change order attribution", "Sales rep management"]
-             * @workflow ["salesrep-management", "commission-updates", "order-attribution", "territory-management"]
-             * @prerequisites ["Valid import UID", "Sales rep modification permissions", "Valid sales rep codes"]
-             * @nextSteps ["api.p21Sism.orderEntry.getSalesrep to verify changes", "api.orders.orders for commission processing"]
-             * @businessRules ["Sales rep validation required", "Commission recalculation triggered", "Territory assignments must be valid"]
-             * @functionalArea "order-entry-processing"
-             * @performance "Updates with validation, triggers commission recalculation workflows"
-             *
-             * @param params Import UID parameter
-             * @returns Promise<BaseResponse<unknown>> Complete response with updated sales representative data
              */
-            updateSalesrep: async (params) => this.executeRequest({
-                method: 'PUT',
-                path: '/import/{importUid}/imp-oe-hdr-salesrep',
-                paramsSchema: schemas_2.OrderEntryHeaderSalesrepParamsSchema,
-                responseSchema: UnknownResponseSchema,
-            }, params, { importUid: params.importUid }),
+            impOeHdrSalesrep: {
+                /**
+                 * Get order entry sales representative details from imp_oe_hdr_salesrep table
+                 *
+                 * @fullPath api.p21Sism.import.impOeHdrSalesrep.get
+                 * @service p21-sism
+                 * @domain order-entry-processing
+                 * @dataMethod getData - returns only the salesrep data without metadata
+                 * @discoverable true
+                 * @searchTerms ["order salesrep", "sales representative", "oe salesrep", "order sales rep", "salesrep data"]
+                 * @relatedEndpoints ["api.p21Sism.import.impOeHdrSalesrep.update", "api.p21Sism.import.impOeHdr.get", "api.orders.orders.salesrep"]
+                 * @commonPatterns ["Get sales rep info", "Process salesrep data", "Order sales rep processing", "Commission processing"]
+                 * @workflow ["salesrep-processing", "commission-calculation", "order-attribution", "sales-management"]
+                 * @prerequisites ["Valid import UID", "Sales rep access permissions", "Import must contain salesrep data"]
+                 * @nextSteps ["api.p21Sism.import.impOeHdrSalesrep.update for modifications", "api.orders.orders for commission processing"]
+                 * @businessRules ["Sales rep assignments affect commission calculation", "Multiple sales reps per order supported", "Territory validation applies"]
+                 * @functionalArea "order-entry-processing"
+                 * @performance "Optimized for sales rep lookup and commission calculations"
+                 *
+                 * @param importUid Import UID parameter
+                 * @returns Promise<BaseResponse<unknown>> Complete response with sales representative data
+                 */
+                get: async (importUid) => this.executeRequest({
+                    method: 'GET',
+                    path: '/import/{importUid}/imp-oe-hdr-salesrep',
+                    paramsSchema: schemas_2.OrderEntryHeaderSalesrepParamsSchema,
+                    responseSchema: UnknownResponseSchema,
+                }, { importUid }, { importUid }),
+                /**
+                 * Update order entry sales representative data in imp_oe_hdr_salesrep table
+                 *
+                 * @fullPath api.p21Sism.import.impOeHdrSalesrep.update
+                 * @service p21-sism
+                 * @domain order-entry-processing
+                 * @dataMethod updateData - returns only the updated salesrep data without metadata
+                 * @discoverable true
+                 * @searchTerms ["update salesrep", "modify sales rep", "salesrep update", "commission update", "sales rep assignment"]
+                 * @relatedEndpoints ["api.p21Sism.import.impOeHdrSalesrep.get", "api.p21Sism.import.impOeHdr.update", "api.orders.orders.updateSalesrep"]
+                 * @commonPatterns ["Update sales rep assignment", "Modify commission data", "Change order attribution", "Sales rep management"]
+                 * @workflow ["salesrep-management", "commission-updates", "order-attribution", "territory-management"]
+                 * @prerequisites ["Valid import UID", "Sales rep modification permissions", "Valid sales rep codes"]
+                 * @nextSteps ["api.p21Sism.import.impOeHdrSalesrep.get to verify changes", "api.orders.orders for commission processing"]
+                 * @businessRules ["Sales rep validation required", "Commission recalculation triggered", "Territory assignments must be valid"]
+                 * @functionalArea "order-entry-processing"
+                 * @performance "Updates with validation, triggers commission recalculation workflows"
+                 *
+                 * @param importUid Import UID parameter
+                 * @returns Promise<BaseResponse<unknown>> Complete response with updated sales representative data
+                 */
+                update: async (importUid) => this.executeRequest({
+                    method: 'PUT',
+                    path: '/import/{importUid}/imp-oe-hdr-salesrep',
+                    paramsSchema: schemas_2.OrderEntryHeaderSalesrepParamsSchema,
+                    responseSchema: UnknownResponseSchema,
+                }, { importUid }, { importUid }),
+                // Data methods
+                getData: async (importUid) => {
+                    const response = await this.import.impOeHdrSalesrep.get(importUid);
+                    return response.data;
+                },
+                updateData: async (importUid) => {
+                    const response = await this.import.impOeHdrSalesrep.update(importUid);
+                    return response.data;
+                },
+            },
             /**
-             * Get order entry web header details from imp_oe_hdr_web table
-             *
-             * @fullPath api.p21Sism.orderEntry.getWebHeader
+             * Import order entry header web operations mirroring /import/{importUid}/imp-oe-hdr-web path
+             * @fullPath api.p21Sism.import.impOeHdrWeb
              * @service p21-sism
              * @domain order-entry-processing
-             * @dataMethod getWebHeaderData - returns only the web header data without metadata
              * @discoverable true
-             * @searchTerms ["web order header", "oe web header", "web order data", "online order header", "e-commerce order"]
-             * @relatedEndpoints ["api.p21Sism.orderEntry.getHeader", "api.p21Sism.orderEntry.getSalesrep", "api.commerce.cartHeaders"]
-             * @commonPatterns ["Get web order data", "Process online orders", "Web order integration", "E-commerce order processing"]
-             * @workflow ["web-order-processing", "e-commerce-integration", "online-order-management", "web-integration"]
-             * @prerequisites ["Valid import UID", "Web order access permissions", "Import must contain web order data"]
-             * @nextSteps ["api.p21Sism.orderEntry.getHeader for complete order data", "api.commerce.cartHeaders for e-commerce processing"]
-             * @businessRules ["Web-specific order attributes included", "Integration with e-commerce systems", "Web order validation rules apply"]
-             * @functionalArea "order-entry-processing"
-             * @performance "Optimized for web order processing and e-commerce integration"
-             *
-             * @param params Import UID parameter
-             * @returns Promise<BaseResponse<unknown>> Complete response with web order header data
              */
-            getWebHeader: async (params) => this.executeRequest({
-                method: 'GET',
-                path: '/import/{importUid}/imp-oe-hdr-web',
-                paramsSchema: schemas_2.OrderEntryHeaderWebParamsSchema,
-                responseSchema: UnknownResponseSchema,
-            }, params, { importUid: params.importUid }),
-            // Data methods for order entry operations
-            getHeaderData: async (params) => {
-                const response = await this.orderEntry.getHeader(params);
-                return response.data;
+            impOeHdrWeb: {
+                /**
+                 * Get order entry web header details from imp_oe_hdr_web table
+                 *
+                 * @fullPath api.p21Sism.import.impOeHdrWeb.get
+                 * @service p21-sism
+                 * @domain order-entry-processing
+                 * @dataMethod getData - returns only the web header data without metadata
+                 * @discoverable true
+                 * @searchTerms ["web order header", "oe web header", "web order data", "online order header", "e-commerce order"]
+                 * @relatedEndpoints ["api.p21Sism.import.impOeHdr.get", "api.p21Sism.import.impOeHdrSalesrep.get", "api.commerce.cartHeaders"]
+                 * @commonPatterns ["Get web order data", "Process online orders", "Web order integration", "E-commerce order processing"]
+                 * @workflow ["web-order-processing", "e-commerce-integration", "online-order-management", "web-integration"]
+                 * @prerequisites ["Valid import UID", "Web order access permissions", "Import must contain web order data"]
+                 * @nextSteps ["api.p21Sism.import.impOeHdr.get for complete order data", "api.commerce.cartHeaders for e-commerce processing"]
+                 * @businessRules ["Web-specific order attributes included", "Integration with e-commerce systems", "Web order validation rules apply"]
+                 * @functionalArea "order-entry-processing"
+                 * @performance "Optimized for web order processing and e-commerce integration"
+                 *
+                 * @param importUid Import UID parameter
+                 * @returns Promise<BaseResponse<unknown>> Complete response with web order header data
+                 */
+                get: async (importUid) => this.executeRequest({
+                    method: 'GET',
+                    path: '/import/{importUid}/imp-oe-hdr-web',
+                    paramsSchema: schemas_2.OrderEntryHeaderWebParamsSchema,
+                    responseSchema: UnknownResponseSchema,
+                }, { importUid }, { importUid }),
+                // Data method
+                getData: async (importUid) => {
+                    const response = await this.import.impOeHdrWeb.get(importUid);
+                    return response.data;
+                },
             },
-            updateHeaderData: async (params) => {
-                const response = await this.orderEntry.updateHeader(params);
+            // Data methods for main import operations
+            listData: async (params) => {
+                const response = await this.import.list(params);
                 return response.data;
             },
-            getSalesrepData: async (params) => {
-                const response = await this.orderEntry.getSalesrep(params);
+            getData: async (importUid) => {
+                const response = await this.import.get(importUid);
                 return response.data;
             },
-            updateSalesrepData: async (params) => {
-                const response = await this.orderEntry.updateSalesrep(params);
+            updateData: async (importUid) => {
+                const response = await this.import.update(importUid);
                 return response.data;
             },
-            getWebHeaderData: async (params) => {
-                const response = await this.orderEntry.getWebHeader(params);
+            deleteData: async (importUid) => {
+                const response = await this.import.delete(importUid);
                 return response.data;
             },
         };
         /**
-         * Scheduled import operations for SFTP metadata management and automated import processing
+         * Scheduled import master operations mirroring /scheduled-import-master path
          * @fullPath api.p21Sism.scheduledImportMaster
          * @service p21-sism
          * @domain scheduled-import-management
@@ -457,77 +538,54 @@ class P21SismClient extends base_client_1.BaseServiceClient {
          */
         this.scheduledImportMaster = {
             /**
-             * Create SFTP metadata for a scheduled import master configuration
-             *
-             * @fullPath api.p21Sism.scheduledImportMaster.createSftpMetadata
+             * Metadata operations for scheduled import master
+             * @fullPath api.p21Sism.scheduledImportMaster.metadata
              * @service p21-sism
              * @domain scheduled-import-management
-             * @dataMethod createSftpMetadataData - returns only the SFTP metadata without response wrapper
              * @discoverable true
-             * @searchTerms ["SFTP metadata", "scheduled import", "import master", "SFTP configuration", "automated import", "file transfer"]
-             * @relatedEndpoints ["api.p21Sism.import.list", "api.p21Sism.import.recent", "api.p21Core.company"]
-             * @commonPatterns ["Configure SFTP import", "Setup automated data transfer", "Scheduled import configuration", "File transfer setup"]
-             * @workflow ["sftp-configuration", "scheduled-imports", "automated-processing", "file-transfer-setup"]
-             * @prerequisites ["Valid scheduled import master UID", "SFTP configuration permissions", "Scheduled import master exists"]
-             * @nextSteps ["api.p21Sism.import.recent to monitor scheduled imports", "SFTP file monitoring systems"]
-             * @businessRules ["SFTP metadata defines transfer parameters", "Scheduled import master must be configured", "File transfer validation rules apply"]
-             * @functionalArea "scheduled-import-management"
-             * @performance "Configuration operation, minimal processing overhead"
-             *
-             * @param params Scheduled import master UID parameter
-             * @returns Promise<BaseResponse<unknown>> Complete response with SFTP metadata configuration
              */
-            createSftpMetadata: async (params) => this.executeRequest({
-                method: 'POST',
-                path: '/scheduled-import-master/{scheduledImportMasterUid}/metadata/sftp',
-                paramsSchema: schemas_2.ScheduledImportSftpParamsSchema,
-                responseSchema: UnknownResponseSchema,
-            }, params, { scheduledImportMasterUid: params.scheduledImportMasterUid }),
-            // Data method for scheduled import operations
-            createSftpMetadataData: async (params) => {
-                const response = await this.scheduledImportMaster.createSftpMetadata(params);
-                return response.data;
-            },
-        };
-        /**
-         * Health check operations for service monitoring and system status verification
-         * @fullPath api.p21Sism.health
-         * @service p21-sism
-         * @domain system-monitoring
-         * @discoverable true
-         */
-        this.health = {
-            /**
-             * Perform health check to verify P21 SISM service status and connectivity
-             *
-             * @fullPath api.p21Sism.health.check
-             * @service p21-sism
-             * @domain system-monitoring
-             * @dataMethod checkData - returns only the health status without metadata
-             * @discoverable true
-             * @searchTerms ["health check", "service status", "system monitor", "service availability", "connectivity test", "SISM health"]
-             * @relatedEndpoints ["api.p21Core.health.check", "api.p21Sism.import.recent", "system monitoring endpoints"]
-             * @commonPatterns ["Check service health", "Monitor system status", "Verify connectivity", "Service diagnostics"]
-             * @workflow ["system-monitoring", "health-verification", "service-diagnostics", "integration-testing"]
-             * @prerequisites ["System access", "Monitoring permissions"]
-             * @nextSteps ["Service remediation if unhealthy", "Integration health checks", "api.p21Sism.import.stuck for processing issues"]
-             * @businessRules ["Returns site configuration", "Includes system hash for verification", "No authentication required for health check"]
-             * @functionalArea "system-monitoring"
-             * @performance "Lightweight check, immediate response, minimal system impact"
-             *
-             * @returns Promise<BaseResponse<HealthCheckResponse>> Service health status and configuration
-             */
-            check: async () => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/health-check',
-                    responseSchema: schemas_2.HealthCheckResponseSchema,
-                });
-            },
-            // Data method for health operations
-            checkData: async () => {
-                const response = await this.health.check();
-                return response.data;
+            metadata: {
+                /**
+                 * SFTP operations for scheduled import master metadata
+                 * @fullPath api.p21Sism.scheduledImportMaster.metadata.sftp
+                 * @service p21-sism
+                 * @domain scheduled-import-management
+                 * @discoverable true
+                 */
+                sftp: {
+                    /**
+                     * Create SFTP metadata for a scheduled import master configuration
+                     *
+                     * @fullPath api.p21Sism.scheduledImportMaster.metadata.sftp.create
+                     * @service p21-sism
+                     * @domain scheduled-import-management
+                     * @dataMethod createData - returns only the SFTP metadata without response wrapper
+                     * @discoverable true
+                     * @searchTerms ["SFTP metadata", "scheduled import", "import master", "SFTP configuration", "automated import", "file transfer"]
+                     * @relatedEndpoints ["api.p21Sism.import.list", "api.p21Sism.import.recent.list", "api.p21Core.company"]
+                     * @commonPatterns ["Configure SFTP import", "Setup automated data transfer", "Scheduled import configuration", "File transfer setup"]
+                     * @workflow ["sftp-configuration", "scheduled-imports", "automated-processing", "file-transfer-setup"]
+                     * @prerequisites ["Valid scheduled import master UID", "SFTP configuration permissions", "Scheduled import master exists"]
+                     * @nextSteps ["api.p21Sism.import.recent.list to monitor scheduled imports", "SFTP file monitoring systems"]
+                     * @businessRules ["SFTP metadata defines transfer parameters", "Scheduled import master must be configured", "File transfer validation rules apply"]
+                     * @functionalArea "scheduled-import-management"
+                     * @performance "Configuration operation, minimal processing overhead"
+                     *
+                     * @param scheduledImportMasterUid Scheduled import master UID parameter
+                     * @returns Promise<BaseResponse<unknown>> Complete response with SFTP metadata configuration
+                     */
+                    create: async (scheduledImportMasterUid) => this.executeRequest({
+                        method: 'POST',
+                        path: '/scheduled-import-master/{scheduledImportMasterUid}/metadata/sftp',
+                        paramsSchema: schemas_2.ScheduledImportSftpParamsSchema,
+                        responseSchema: UnknownResponseSchema,
+                    }, { scheduledImportMasterUid }, { scheduledImportMasterUid }),
+                    // Data method
+                    createData: async (scheduledImportMasterUid) => {
+                        const response = await this.scheduledImportMaster.metadata.sftp.create(scheduledImportMasterUid);
+                        return response.data;
+                    },
+                },
             },
         };
         /**
@@ -540,7 +598,7 @@ class P21SismClient extends base_client_1.BaseServiceClient {
              * @returns Promise<unknown> Health status data directly
              */
             check: async () => {
-                const response = await this.health.check();
+                const response = await this.healthCheck.get();
                 return response.data;
             },
         };