import { AutoScanner, AutoScannerConfig, ScanResult } from './auto-scanner';
import { RouteTransformer, TransformerConfig, TransformedRoute, TransformResult } from './route-transformer';
import { PathExtractorConfig } from './path-extractor';
/**
 * Discovery engine configuration
 */
export interface DiscoveryEngineConfig {
    /** Root directory for discovery */
    readonly rootDir: string;
    /** Scanner configuration */
    readonly scanner?: Partial<AutoScannerConfig>;
    /** Transformer configuration */
    readonly transformer?: Partial<TransformerConfig>;
    /** Path extractor configuration */
    readonly extractor?: Partial<PathExtractorConfig>;
    /** Enable validation during discovery */
    readonly validate?: boolean;
    /** Enable conflict detection */
    readonly detectConflicts?: boolean;
    /** Enable code generation */
    readonly generateCode?: boolean;
    /** Output directory for generated code */
    readonly outputDir?: string;
    /** Event handlers for discovery lifecycle */
    readonly handlers?: DiscoveryHandlers;
    /** Feature flag for discovery engine */
    readonly featureFlag?: string;
}
/**
 * Discovery lifecycle event handlers
 */
export interface DiscoveryHandlers {
    /** Called before scanning starts */
    readonly onScanStart?: () => void | Promise<void>;
    /** Called after scanning completes */
    readonly onScanComplete?: (result: ScanResult) => void | Promise<void>;
    /** Called before transformation starts */
    readonly onTransformStart?: () => void | Promise<void>;
    /** Called after transformation completes */
    readonly onTransformComplete?: (result: TransformResult) => void | Promise<void>;
    /** Called when a route is discovered */
    readonly onRouteDiscovered?: (route: TransformedRoute) => void | Promise<void>;
    /** Called when validation errors occur */
    readonly onValidationError?: (errors: readonly ValidationError[]) => void | Promise<void>;
    /** Called when conflicts are detected */
    readonly onConflict?: (conflicts: readonly RouteConflict[]) => void | Promise<void>;
    /** Called when discovery completes */
    readonly onComplete?: (result: DiscoveryResult) => void | Promise<void>;
    /** Called when an error occurs */
    readonly onError?: (error: Error) => void | Promise<void>;
}
/**
 * Validation error in discovered routes
 */
export interface ValidationError {
    /** Error type */
    readonly type: 'invalid-path' | 'invalid-segment' | 'missing-export' | 'invalid-param';
    /** Route that caused the error */
    readonly routeId: string;
    /** File path */
    readonly filePath: string;
    /** Error message */
    readonly message: string;
    /** Error details */
    readonly details?: Record<string, unknown>;
}
/**
 * Route conflict between discovered routes
 */
export interface RouteConflict {
    /** Conflict type */
    readonly type: 'exact-duplicate' | 'param-conflict' | 'catch-all-shadow' | 'ambiguous';
    /** Routes involved in conflict */
    readonly routes: readonly TransformedRoute[];
    /** Path pattern where conflict occurs */
    readonly path: string;
    /** Conflict severity */
    readonly severity: 'error' | 'warning';
    /** Conflict message */
    readonly message: string;
    /** Suggested resolution */
    readonly suggestion?: string;
}
/**
 * Complete discovery result
 */
export interface DiscoveryResult {
    /** Discovered and transformed routes */
    readonly routes: readonly TransformedRoute[];
    /** Route tree structure */
    readonly tree: TransformResult['tree'];
    /** Scan result */
    readonly scan: ScanResult;
    /** Transform result */
    readonly transform: TransformResult;
    /** Validation errors (if validation enabled) */
    readonly validationErrors: readonly ValidationError[];
    /** Route conflicts (if conflict detection enabled) */
    readonly conflicts: readonly RouteConflict[];
    /** Generated code (if code generation enabled) */
    readonly generatedCode?: GeneratedCode;
    /** Discovery statistics */
    readonly stats: DiscoveryStats;
    /** Discovery timestamp */
    readonly timestamp: number;
}
/**
 * Generated code from discovery
 */
export interface GeneratedCode {
    /** Route configuration code */
    readonly routeConfig: string;
    /** Type definitions */
    readonly typeDefinitions: string;
    /** Route manifest */
    readonly manifest: string;
}
/**
 * Discovery statistics
 */
export interface DiscoveryStats {
    /** Total discovery duration (ms) */
    readonly totalDurationMs: number;
    /** Scan duration (ms) */
    readonly scanDurationMs: number;
    /** Transform duration (ms) */
    readonly transformDurationMs: number;
    /** Validation duration (ms) */
    readonly validationDurationMs: number;
    /** Files scanned */
    readonly filesScanned: number;
    /** Routes discovered */
    readonly routesDiscovered: number;
    /** Validation errors count */
    readonly validationErrorCount: number;
    /** Conflicts count */
    readonly conflictCount: number;
}
/**
 * Discovery engine state
 */
export type DiscoveryState = 'idle' | 'scanning' | 'transforming' | 'validating' | 'generating' | 'complete' | 'error';
/**
 * Discovery event types
 */
export type DiscoveryEventType = 'state-change' | 'route-discovered' | 'validation-error' | 'conflict-detected' | 'complete' | 'error';
/**
 * Discovery event payload
 */
export interface DiscoveryEvent {
    readonly type: DiscoveryEventType;
    readonly timestamp: number;
    readonly data: unknown;
}
/**
 * Discovery event listener
 */
export type DiscoveryEventListener = (event: DiscoveryEvent) => void;
/**
 * Default discovery engine configuration
 */
export declare const DEFAULT_DISCOVERY_ENGINE_CONFIG: Partial<DiscoveryEngineConfig>;
/**
 * Main orchestrator for route discovery
 *
 * @example
 * ```typescript
 * const engine = new DiscoveryEngine({
 *   rootDir: process.cwd(),
 *   scanPaths: ['src/routes'],
 * });
 *
 * // Add event listener
 * engine.on('route-discovered', (event) => {
 *   console.log('Discovered:', event.data);
 * });
 *
 * // Run discovery
 * const result = await engine.discover();
 * ```
 */
export declare class DiscoveryEngine {
    private readonly config;
    private readonly scanner;
    private readonly transformer;
    private state;
    private readonly listeners;
    private lastResult;
    constructor(config: DiscoveryEngineConfig);
    /**
     * Get current discovery state
     */
    getState(): DiscoveryState;
    /**
     * Get last discovery result
     */
    getLastResult(): DiscoveryResult | null;
    /**
     * Add event listener
     */
    on(type: DiscoveryEventType, listener: DiscoveryEventListener): () => void;
    /**
     * Remove event listener
     */
    off(type: DiscoveryEventType, listener: DiscoveryEventListener): void;
    /**
     * Run the discovery process
     *
     * @param forceRefresh - Skip cache and perform fresh discovery
     * @returns Discovery result
     */
    discover(forceRefresh?: boolean): Promise<DiscoveryResult>;
    /**
     * Clear scanner cache
     */
    clearCache(): void;
    /**
     * Get scanner instance for advanced usage
     */
    getScanner(): AutoScanner;
    /**
     * Get transformer instance for advanced usage
     */
    getTransformer(): RouteTransformer;
    /**
     * Emit an event
     */
    private emit;
    /**
     * Update state and emit state change event
     */
    private setState;
    /**
     * Validate discovered routes
     */
    private validateRoutes;
    /**
     * Detect conflicts between routes
     */
    private detectConflicts;
    /**
     * Check if two routes conflict
     *
     * Uses core splitPath utility for path segmentation.
     */
    private doRoutesConflict;
    /**
     * Generate code from discovered routes
     */
    private generateCode;
}
/**
 * Create a new DiscoveryEngine instance
 *
 * @param config - Engine configuration
 * @returns Configured DiscoveryEngine
 */
export declare function createDiscoveryEngine(config: DiscoveryEngineConfig): DiscoveryEngine;
/**
 * Run a one-shot discovery (convenience function)
 *
 * @param rootDir - Root directory to scan
 * @param options - Discovery options
 * @returns Discovery result
 */
export declare function discoverRoutes(rootDir: string, options?: Partial<Omit<DiscoveryEngineConfig, 'rootDir'>>): Promise<DiscoveryResult>;
/**
 * Get or create the default discovery engine
 *
 * @param config - Configuration for default engine (only used on first call)
 * @returns Default discovery engine instance
 */
export declare function getDiscoveryEngine(config?: DiscoveryEngineConfig): DiscoveryEngine;
/**
 * Initialize the default discovery engine
 *
 * @param config - Engine configuration
 */
export declare function initDiscoveryEngine(config: DiscoveryEngineConfig): void;
/**
 * Reset the default discovery engine
 */
export declare function resetDiscoveryEngine(): void;