/**
 * Memory Portability Framework
 * Phase 4.0 Week 1: Enhanced memory export/import with enterprise security
 * Integrates with existing Phase 4 components for complete data portability
 */
import { EventEmitter } from "node:events";
import type { EnterpriseDataPorter } from "./enterprise-data-porter";
import type { FormatHandlerRegistry } from "./formats/FormatHandlerRegistry";
import type { ValidationEngine } from "./validation/ValidationEngine";
import type { EnterpriseSecurityManager } from "./enterprise-security-manager";
import type { EnterpriseAuditLogger } from "./enterprise-audit-logger";
import type { AccessControlManager } from "../enterprise/access-control-manager";
import type { DualMemoryEngine } from "../dual-memory-engine";
export interface PortabilityConfig {
    organizationId: string;
    defaultFormat: "json" | "csv" | "parquet" | "xml";
    enableEncryption: boolean;
    enableCompression: boolean;
    enableValidation: boolean;
    auditExportImport: boolean;
    maxExportSize: number;
    allowedFormats: string[];
    securityClassification: "public" | "internal" | "confidential" | "secret";
}
export interface ExportRequest {
    userId: string;
    sessionId: string;
    format: string;
    filter: MemoryFilter;
    options: ExportOptions;
    requestId: string;
    timestamp: Date;
}
export interface MemoryFilter {
    dateRange?: {
        start: Date;
        end: Date;
    };
    memoryTypes?: string[];
    tags?: string[];
    classification?: string[];
    ownership?: "own" | "team" | "project" | "organization";
    excludeFields?: string[];
}
export interface ExportOptions {
    includeMetadata: boolean;
    anonymizeData: boolean;
    compressOutput: boolean;
    encryptOutput: boolean;
    splitLargeFiles: boolean;
    maxFileSize: number;
    outputPath?: string;
}
export interface ImportRequest {
    userId: string;
    sessionId: string;
    filePath: string;
    format: string;
    options: ImportOptions;
    requestId: string;
    timestamp: Date;
}
export interface ImportOptions {
    validateSchema: boolean;
    skipDuplicates: boolean;
    overwriteExisting: boolean;
    preserveIds: boolean;
    targetMemoryType?: string;
    batchSize: number;
}
export interface PortabilityResult {
    requestId: string;
    success: boolean;
    recordsProcessed: number;
    recordsSkipped: number;
    recordsErrors: number;
    outputFiles?: string[];
    errors?: PortabilityError[];
    metadata: PortabilityMetadata;
    duration: number;
}
export interface PortabilityError {
    record: number;
    field?: string;
    error: string;
    severity: "warning" | "error" | "critical";
}
export interface PortabilityMetadata {
    exportId: string;
    organizationId: string;
    userId: string;
    timestamp: Date;
    format: string;
    totalRecords: number;
    dataClassification: string;
    schema: unknown;
    checksums: {
        [algorithm: string]: string;
    };
    compression?: {
        algorithm: string;
        ratio: number;
    };
    encryption?: {
        algorithm: string;
        keyId: string;
    };
}
export interface MigrationPlan {
    id: string;
    name: string;
    description: string;
    sourceSystem: string;
    targetSystem: string;
    mappings: FieldMapping[];
    transformations: DataTransformation[];
    validations: ValidationRule[];
    schedule?: MigrationSchedule;
}
export interface FieldMapping {
    sourceField: string;
    targetField: string;
    transformation?: string;
    required: boolean;
    defaultValue?: unknown;
}
export interface DataTransformation {
    type: "rename" | "convert" | "calculate" | "filter" | "aggregate";
    expression: string;
    parameters: {
        [key: string]: unknown;
    };
}
export interface ValidationRule {
    field: string;
    type: "required" | "format" | "range" | "custom";
    condition: string;
    message: string;
}
export interface MigrationSchedule {
    startTime: Date;
    endTime?: Date;
    batchSize: number;
    interval: number;
    maxConcurrentJobs: number;
}
/**
 * Memory Portability Framework
 * Orchestrates memory export/import operations with enterprise security
 */
export declare class MemoryPortabilityFramework extends EventEmitter {
    private config;
    private dataPorter;
    private formatRegistry;
    private validationEngine;
    private securityManager;
    private auditLogger;
    private accessControl;
    private memoryEngine;
    private activeJobs;
    private migrationPlans;
    constructor(config: PortabilityConfig, dependencies: {
        dataPorter: EnterpriseDataPorter;
        formatRegistry: FormatHandlerRegistry;
        validationEngine: ValidationEngine;
        securityManager: EnterpriseSecurityManager;
        auditLogger: EnterpriseAuditLogger;
        accessControl: AccessControlManager;
        memoryEngine: DualMemoryEngine;
    });
    /**
     * Export memories with security and validation
     */
    exportMemories(request: ExportRequest): Promise<PortabilityResult>;
    /**
     * Import memories with validation and conflict resolution
     */
    importMemories(request: ImportRequest): Promise<PortabilityResult>;
    /**
     * Create and execute migration plan
     */
    executeMigration(planId: string, userId: string): Promise<PortabilityResult>;
    /**
     * Get list of supported formats
     */
    getSupportedFormats(): string[];
    /**
     * Get active portability jobs
     */
    getActiveJobs(): PortabilityJob[];
    /**
     * Cancel a running job
     */
    cancelJob(jobId: string): Promise<boolean>;
    /**
     * Private helper methods
     */
    private initializeFramework;
    private authorizeDataAccess;
    private validateExportRequest;
    private validateImportRequest;
    private createExportJob;
    private createImportJob;
    private retrieveMemories;
    private processMemoriesForExport;
    private generateExportFiles;
    private createExportMetadata;
    private parseImportFile;
    private processMemoriesForImport;
    private storeImportedMemories;
    private createFailureMetadata;
    private createMigrationMetadata;
    private estimateExportSize;
    private anonymizeMemories;
    private createDefaultMigrationPlans;
    private cleanupCompletedJobs;
}
interface PortabilityJob {
    id: string;
    type: "export" | "import" | "migration";
    status: "running" | "completed" | "failed" | "cancelled";
    progress: number;
    startTime: Date;
    endTime?: Date;
    request: ExportRequest | ImportRequest;
    cancelled: boolean;
    error?: string;
}
/**
 * Factory function to create memory portability framework
 */
export declare function createMemoryPortabilityFramework(config: PortabilityConfig, dependencies: {
    dataPorter: EnterpriseDataPorter;
    formatRegistry: FormatHandlerRegistry;
    validationEngine: ValidationEngine;
    securityManager: EnterpriseSecurityManager;
    auditLogger: EnterpriseAuditLogger;
    accessControl: AccessControlManager;
    memoryEngine: DualMemoryEngine;
}): MemoryPortabilityFramework;
export {};