@simpleapps-com/augur-api/dist/cjs/services/p21-sism/resources/import.js

TypeScript client library for Augur microservices API endpoints

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createImportResource = createImportResource;
exports.createImportDataResource = createImportDataResource;
const schemas_1 = require("../schemas");
const schemas_2 = require("../../../core/schemas");
const zod_1 = require("zod");
// Create flexible response schemas using the STANDARD 8-field response format
const UnknownResponseSchema = (0, schemas_2.BaseResponseSchema)(zod_1.z.unknown());
const UnknownArrayResponseSchema = (0, schemas_2.BaseResponseSchema)(zod_1.z.array(zod_1.z.unknown()));
/**
 * Creates the import resource methods
 * OpenAPI Path: /import → import.*
 * @description Methods for import management operations
 */
function createImportResource(executeRequest, createListMethod) {
    return {
        /**
         * List imports with filtering capabilities for data management and monitoring
         *
         * @fullPath api.p21Sism.import.list
         * @service p21-sism
         * @domain data-import-management
         * @dataMethod importData.list
         * @discoverable true
         * @searchTerms ["imports", "data import", "import list", "batch processing", "data synchronization", "import management"]
         * @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"]
         * @nextSteps ["api.p21Sism.import.get for details", "api.p21Sism.import.update for modifications"]
         * @businessRules ["Import states: initial, hold, delivered", "Supports pagination and filtering", "Search by reference number or source name"]
         * @functionalArea "data-import-management"
         * @caching "Cache for 5 minutes, invalidate on import state changes"
         * @performance "Indexed by import state and date, supports text search across multiple fields"
         *
         * @param params Optional filtering and pagination parameters
         * @returns Promise<BaseResponse<Import[]>> Complete response with imports array and metadata
         */
        list: createListMethod('/import', schemas_1.ImportListParamsSchema, UnknownArrayResponseSchema),
        /**
         * Get import details by UID for comprehensive import information
         *
         * @fullPath api.p21Sism.import.get
         * @service p21-sism
         * @domain data-import-management
         * @dataMethod importData.get
         * @discoverable true
         * @searchTerms ["import details", "import info", "import status", "import data", "import processing"]
         * @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.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 importUid Import UID parameter
         * @returns Promise<BaseResponse<Import>> Complete response with detailed import information
         */
        get: async (importUid) => executeRequest({
            method: 'GET',
            path: '/import/{importUid}',
            paramsSchema: schemas_1.ImportDetailParamsSchema,
            responseSchema: UnknownResponseSchema,
        }, { importUid }, { importUid }),
        /**
         * Update import details and processing status
         *
         * @fullPath api.p21Sism.import.update
         * @service p21-sism
         * @domain data-import-management
         * @dataMethod importData.update
         * @discoverable true
         * @searchTerms ["update import", "modify import", "import processing", "import status change", "import management"]
         * @relatedEndpoints ["api.p21Sism.import.get", "api.p21Sism.import.list", "api.p21Sism.import.delete"]
         * @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.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 importUid Import UID parameter
         * @returns Promise<BaseResponse<Import>> Complete response with updated import information
         */
        update: async (importUid) => executeRequest({
            method: 'PUT',
            path: '/import/{importUid}',
            paramsSchema: schemas_1.ImportDetailParamsSchema,
            responseSchema: UnknownResponseSchema,
        }, { importUid }, { importUid }),
        /**
         * Clean pending import data for import cleanup and maintenance
         *
         * @fullPath api.p21Sism.import.delete
         * @service p21-sism
         * @domain data-import-management
         * @dataMethod importData.delete
         * @discoverable true
         * @searchTerms ["delete import", "clean import", "remove import", "import cleanup", "pending import cleanup"]
         * @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"]
         * @nextSteps ["api.p21Sism.import.list to verify removal", "system maintenance workflows"]
         * @businessRules ["Only cleans pending import data", "Does not affect completed imports", "Maintains audit trail"]
         * @functionalArea "data-import-management"
         * @performance "Cleanup operation with validation, affects related pending data"
         *
         * @param importUid Import UID parameter
         * @returns Promise<BaseResponse<Import>> Complete response with cleanup confirmation
         */
        delete: async (importUid) => executeRequest({
            method: 'DELETE',
            path: '/import/{importUid}',
            paramsSchema: schemas_1.ImportDetailParamsSchema,
            responseSchema: UnknownResponseSchema,
        }, { importUid }, { importUid }),
        /**
         * Recent imports operations for monitoring and status tracking
         * @fullPath api.p21Sism.import.recent
         * @service p21-sism
         * @domain data-import-management
         * @discoverable true
         */
        recent: {
            /**
             * Get recent imports for monitoring and status tracking
             *
             * @fullPath api.p21Sism.import.recent.list
             * @service p21-sism
             * @domain data-import-management
             * @dataMethod importData.recent.list
             * @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
             */
            list: createListMethod('/import/recent', schemas_1.ImportRecentParamsSchema, UnknownArrayResponseSchema),
        },
        /**
         * Stuck imports operations for troubleshooting and error resolution
         * @fullPath api.p21Sism.import.stuck
         * @service p21-sism
         * @domain data-import-management
         * @discoverable true
         */
        stuck: {
            /**
             * Get stuck imports for troubleshooting and error resolution
             *
             * @fullPath api.p21Sism.import.stuck.list
             * @service p21-sism
             * @domain data-import-management
             * @dataMethod importData.stuck.list
             * @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
             */
            list: createListMethod('/import/stuck', schemas_1.ImportStuckParamsSchema, UnknownArrayResponseSchema),
        },
        /**
         * Import order entry header operations mirroring /import/{importUid}/imp-oe-hdr path
         * @fullPath api.p21Sism.import.impOeHdr
         * @service p21-sism
         * @domain order-entry-processing
         * @discoverable true
         */
        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 importData.impOeHdr.get
             * @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) => executeRequest({
                method: 'GET',
                path: '/import/{importUid}/imp-oe-hdr',
                paramsSchema: schemas_1.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 importData.impOeHdr.update
             * @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) => executeRequest({
                method: 'PUT',
                path: '/import/{importUid}/imp-oe-hdr',
                paramsSchema: schemas_1.OrderEntryHeaderParamsSchema,
                responseSchema: UnknownResponseSchema,
            }, { importUid }, { importUid }),
        },
        /**
         * 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
         * @discoverable true
         */
        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 importData.impOeHdrSalesrep.get
             * @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) => executeRequest({
                method: 'GET',
                path: '/import/{importUid}/imp-oe-hdr-salesrep',
                paramsSchema: schemas_1.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 importData.impOeHdrSalesrep.update
             * @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) => executeRequest({
                method: 'PUT',
                path: '/import/{importUid}/imp-oe-hdr-salesrep',
                paramsSchema: schemas_1.OrderEntryHeaderSalesrepParamsSchema,
                responseSchema: UnknownResponseSchema,
            }, { importUid }, { importUid }),
        },
        /**
         * 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
         * @discoverable true
         */
        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 importData.impOeHdrWeb.get
             * @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) => executeRequest({
                method: 'GET',
                path: '/import/{importUid}/imp-oe-hdr-web',
                paramsSchema: schemas_1.OrderEntryHeaderWebParamsSchema,
                responseSchema: UnknownResponseSchema,
            }, { importUid }, { importUid }),
        },
    };
}
/**
 * Creates the importData resource methods (data-only versions)
 */
function createImportDataResource(importResource) {
    return {
        list: async (params) => {
            const response = await importResource.list(params);
            return response.data;
        },
        get: async (importUid) => {
            const response = await importResource.get(importUid);
            return response.data;
        },
        update: async (importUid) => {
            const response = await importResource.update(importUid);
            return response.data;
        },
        delete: async (importUid) => {
            const response = await importResource.delete(importUid);
            return response.data;
        },
        recent: {
            list: async (params) => {
                const response = await importResource.recent.list(params);
                return response.data;
            },
        },
        stuck: {
            list: async (params) => {
                const response = await importResource.stuck.list(params);
                return response.data;
            },
        },
        impOeHdr: {
            get: async (importUid) => {
                const response = await importResource.impOeHdr.get(importUid);
                return response.data;
            },
            update: async (importUid) => {
                const response = await importResource.impOeHdr.update(importUid);
                return response.data;
            },
        },
        impOeHdrSalesrep: {
            get: async (importUid) => {
                const response = await importResource.impOeHdrSalesrep.get(importUid);
                return response.data;
            },
            update: async (importUid) => {
                const response = await importResource.impOeHdrSalesrep.update(importUid);
                return response.data;
            },
        },
        impOeHdrWeb: {
            get: async (importUid) => {
                const response = await importResource.impOeHdrWeb.get(importUid);
                return response.data;
            },
        },
    };
}
//# sourceMappingURL=import.js.map