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

TypeScript client library for Augur microservices API endpoints

import { type ImportListParams, type ImportRecentParams, type ImportStuckParams } from '../schemas';
import type { BaseResponse } from '../../../core/base-client';
import type { P21SismClient } from '../client';
type ExecuteRequest = P21SismClient['executeRequest'];
type CreateListMethod = P21SismClient['createListMethod'];
/**
 * Creates the import resource methods
 * OpenAPI Path: /import → import.*
 * @description Methods for import management operations
 */
export declare function createImportResource(executeRequest: ExecuteRequest, createListMethod: CreateListMethod): {
    /**
     * 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: (params?: {
        limit?: number | undefined;
        offset?: number | undefined;
        q?: string | undefined;
        orderBy?: string | undefined;
        importState?: "initial" | "hold" | "delivered" | undefined;
    } | undefined) => Promise<BaseResponse<unknown[]>>;
    /**
     * 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: (importUid: string) => Promise<BaseResponse<unknown>>;
    /**
     * 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: (importUid: string) => Promise<BaseResponse<unknown>>;
    /**
     * 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: (importUid: string) => Promise<BaseResponse<unknown>>;
    /**
     * 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: (params?: {
            limit?: number | undefined;
            hours?: number | undefined;
        } | undefined) => Promise<BaseResponse<unknown[]>>;
    };
    /**
     * 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: (params?: {
            limit?: number | undefined;
            hours?: number | undefined;
        } | undefined) => Promise<BaseResponse<unknown[]>>;
    };
    /**
     * 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: (importUid: string) => Promise<BaseResponse<unknown>>;
        /**
         * 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: (importUid: string) => Promise<BaseResponse<unknown>>;
    };
    /**
     * 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: (importUid: string) => Promise<BaseResponse<unknown>>;
        /**
         * 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: (importUid: string) => Promise<BaseResponse<unknown>>;
    };
    /**
     * 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: (importUid: string) => Promise<BaseResponse<unknown>>;
    };
};
/**
 * Creates the importData resource methods (data-only versions)
 */
export declare function createImportDataResource(importResource: ReturnType<typeof createImportResource>): {
    list: (params?: ImportListParams) => Promise<unknown[]>;
    get: (importUid: string) => Promise<unknown>;
    update: (importUid: string) => Promise<unknown>;
    delete: (importUid: string) => Promise<unknown>;
    recent: {
        list: (params?: ImportRecentParams) => Promise<unknown[]>;
    };
    stuck: {
        list: (params?: ImportStuckParams) => Promise<unknown[]>;
    };
    impOeHdr: {
        get: (importUid: string) => Promise<unknown>;
        update: (importUid: string) => Promise<unknown>;
    };
    impOeHdrSalesrep: {
        get: (importUid: string) => Promise<unknown>;
        update: (importUid: string) => Promise<unknown>;
    };
    impOeHdrWeb: {
        get: (importUid: string) => Promise<unknown>;
    };
};
export type ImportResource = ReturnType<typeof createImportResource>;
export type ImportDataResource = ReturnType<typeof createImportDataResource>;
export {};
//# sourceMappingURL=import.d.ts.map