import { ClaudeCodeLayer } from '../layers/ClaudeCodeLayer.js';
import { AntigravityCLILayer } from '../layers/AntigravityCLILayer.js';
import { AIStudioLayer } from '../layers/AIStudioLayer.js';
import { Config, ExecutionPlan, FileReference, LayerResult, LayerType, ProcessingOptions, WorkflowResult, WorkflowType } from './types.js';
export declare function assertNoCredentialFiles(task: unknown): void;
export interface ExecutionOptions {
    executionMode: 'sequential' | 'parallel' | 'adaptive';
    timeout?: number;
    maxRetries?: number;
}
interface TaskAnalysis {
    complexity: 'low' | 'medium' | 'high';
    hasFiles: boolean;
    fileTypes: string[];
    needsCurrentInfo: boolean;
    isGenerationTask: boolean;
    isCodeRelated: boolean;
    estimatedTokens: number;
    preferredLayer: LayerType;
    reasoning: string;
}
export declare class LayerManager {
    private claudeLayer;
    private antigravityLayer;
    private aiStudioLayer;
    private config;
    private layerInitialized;
    private claudeLayerPromise;
    private antigravityLayerPromise;
    private aiStudioLayerPromise;
    constructor(config: Config);
    getClaudeLayer(): ClaudeCodeLayer;
    getAntigravityLayer(): AntigravityCLILayer;
    getGeminiLayer(): AntigravityCLILayer;
    getGeminiLayerAsync(): Promise<AntigravityCLILayer>;
    getAIStudioLayer(): AIStudioLayer;
    getClaudeLayerAsync(): Promise<ClaudeCodeLayer>;
    getAntigravityLayerAsync(): Promise<AntigravityCLILayer>;
    getAIStudioLayerAsync(): Promise<AIStudioLayer>;
    processSimpleFast(prompt: string, files?: FileReference[]): Promise<LayerResult>;
    analyzeTask(task: any, userPreferredLayer?: LayerType): TaskAnalysis;
    executeWithOptimalLayer(task: any): Promise<LayerResult>;
    executeWithLayer(layerType: LayerType, task: any): Promise<LayerResult>;
    private executeWithFallback;
    private static readonly FILE_CAPABLE_LAYERS;
    private getFallbackOrder;
    private ensureLayerInitialized;
    detectFileType(path: string): string;
    private detectCodeContent;
    private detectCurrentInfoNeed;
    private detectGenerationTask;
    private assessComplexity;
    private isSimplePrompt;
    initializeLayers(): Promise<void>;
    processMultimodal(prompt: string, files: FileReference[], workflow: WorkflowType, options?: ProcessingOptions): Promise<WorkflowResult>;
    analyzeDocuments(documents: string[], analysisType: string, outputRequirements?: string, options?: ProcessingOptions): Promise<WorkflowResult>;
    executeWorkflow(workflow: ExecutionPlan, inputData: Record<string, unknown>, options: ExecutionOptions): Promise<WorkflowResult>;
    private executeSequential;
    private executeParallel;
    private executeAdaptive;
    private analyzeWorkload;
    private publishedOutput;
    private executeHybrid;
    private tryFallbackStrategy;
    private createWorkflowPlan;
    private createAnalysisWorkflow;
    private createConversionWorkflow;
    private createExtractionWorkflow;
    private createGenerationWorkflow;
    private getLayer;
    private getLayerAsync;
    private topologicalSort;
    private groupStepsByDependencies;
    private groupStepsByRecommendedLayer;
    private resolveStepInput;
    private generateWorkflowSummary;
    private calculateTotalCost;
    private detectGenerationRequest;
    private detectImageGeneration;
    private detectAudioGeneration;
    private detectDocumentProcessing;
    private executeStep;
    private validateStepResult;
    private mapActionToTaskType;
}
export {};
//# sourceMappingURL=LayerManager.d.ts.map