/**
 * MIGRATION UTILITIES FOR UNIVERSAL CAPABILITY FRAMEWORK
 *
 * Utilities to help migrate existing capabilities to the Universal Capability Framework.
 * These tools provide automated migration, compatibility layers, and validation.
 */
import type { CapabilityContribution, CapabilityContext } from '../runtime/agentHost.js';
import type { ToolDefinition, ToolSuite } from '../core/toolRuntime.js';
import { UniversalCapabilityModule } from './universalCapabilityFramework.js';
import { UniversalCapabilityFramework } from './universalCapabilityFramework.js';
export interface LegacyCapability {
    id: string;
    name: string;
    description: string;
    tools?: ToolDefinition[];
    toolSuite?: ToolSuite;
    metadata?: Record<string, any>;
    create?(context: CapabilityContext): Promise<CapabilityContribution>;
    execute?(params: any): Promise<any>;
}
export interface MigrationReport {
    legacyCapability: LegacyCapability;
    migratedCapability: any;
    success: boolean;
    errors: string[];
    warnings: string[];
    migrationTime: number;
    compatibilityScore: number;
}
export interface MigrationOptions {
    /** Preserve original capability alongside migrated version */
    preserveOriginal: boolean;
    /** Generate compatibility layer */
    generateCompatibilityLayer: boolean;
    /** Validate migration results */
    validateMigration: boolean;
    /** Output directory for migration artifacts */
    outputDir: string;
    /** Log level for migration process */
    logLevel: 'silent' | 'info' | 'debug';
}
export declare class CapabilityMigrator {
    private framework;
    private options;
    constructor(framework: UniversalCapabilityFramework, options?: Partial<MigrationOptions>);
    /**
     * Migrate a legacy capability to UniversalCapabilityModule
     */
    migrateCapability(legacyCapability: LegacyCapability): Promise<MigrationReport>;
    /**
     * Analyze a legacy capability for migration compatibility
     */
    private analyzeLegacyCapability;
    /**
     * Generate migrated capability class
     */
    private generateMigratedCapability;
    /**
     * Generate compatibility layer for legacy code
     */
    private generateCompatibilityLayer;
    /**
     * Generate TypeScript code for compatibility layer
     */
    private generateCompatibilityCode;
    /**
     * Save migration artifacts
     */
    private saveMigrationArtifacts;
    /**
     * Validate migration results
     */
    private validateMigration;
    /**
     * Generate a migrated ID from legacy ID
     */
    private generateMigratedId;
    /**
     * Generate class name from ID
     */
    private generateClassName;
    /**
     * Generate factory name from ID
     */
    private generateFactoryName;
    /**
     * Get factory ID from migrated ID
     */
    private getFactoryId;
    /**
     * Log message with level
     */
    private log;
    /**
     * Batch migrate multiple capabilities
     */
    migrateCapabilities(capabilities: LegacyCapability[]): Promise<MigrationReport[]>;
    /**
     * Analyze directory for legacy capabilities
     */
    analyzeDirectory(dirPath: string): {
        capabilities: LegacyCapability[];
        totalFiles: number;
        compatibleFiles: number;
        analysis: Record<string, any>;
    };
}
/**
 * Create a migration-ready framework instance
 */
export declare function createMigrationFramework(config?: any): UniversalCapabilityFramework;
/**
 * Register migrated capabilities with factory
 */
export declare function registerMigratedCapabilities(framework: UniversalCapabilityFramework, migratedClasses: Array<new (framework: UniversalCapabilityFramework, config: any) => UniversalCapabilityModule>): void;
/**
 * Generate migration report from results
 */
export declare function generateMigrationReport(results: MigrationReport[]): string;
/**
 * Quick migration utility for common patterns
 */
export declare function quickMigrate(legacyCapability: LegacyCapability, options?: Partial<MigrationOptions>): Promise<MigrationReport>;
/**
 * Quick batch migration
 */
export declare function quickBatchMigrate(capabilities: LegacyCapability[], options?: Partial<MigrationOptions>): Promise<MigrationReport[]>;
//# sourceMappingURL=migrationUtilities.d.ts.map