import type { EventBus } from './EventBus.js';
import type { AuditStore } from './AuditStore.js';
import type { SecuritySentinel } from './SecuritySentinel.js';
import type { ConfirmationManager } from './ConfirmationManager.js';
import { TaskDecomposer } from './TaskDecomposer.js';
import type { DecomposedTask, TaskStep, StepStatus } from './TaskDecomposer.js';
import { CollaborationProtocol } from './CollaborationProtocol.js';
import type { AgentAssignment } from './CollaborationProtocol.js';
export type AutonomyMode = 'suggest' | 'auto' | 'disabled';
export interface StepResult {
    stepId: string;
    status: StepStatus;
    agentName: string;
    output?: string;
    error?: string;
    startedAt: string;
    completedAt: string;
    durationMs: number;
}
export interface ExecutionResult {
    taskId: string;
    mode: AutonomyMode;
    status: 'completed' | 'partial' | 'failed' | 'pending_confirmation' | 'suggested';
    stepResults: StepResult[];
    totalDurationMs: number;
    startedAt: string;
    completedAt: string;
}
export interface TaskProgress {
    taskId: string;
    totalSteps: number;
    completedSteps: number;
    currentStep: string | null;
    percentComplete: number;
    status: 'pending' | 'running' | 'completed' | 'failed';
}
export type StepExecutor = (step: TaskStep, assignment: AgentAssignment) => Promise<{
    success: boolean;
    output?: string;
    error?: string;
}>;
export interface OrchestratorDeps {
    eventBus: EventBus;
    auditStore: AuditStore;
    sentinel: SecuritySentinel;
    confirmationManager?: ConfirmationManager;
    stepExecutor?: StepExecutor;
    maxConcurrentSteps?: number;
    maxStepTimeoutS?: number;
}
export declare class AutonomyOrchestrator {
    private readonly decomposer;
    private readonly protocol;
    private readonly eventBus;
    private readonly auditStore;
    private readonly sentinel;
    private readonly confirmationManager?;
    private readonly stepExecutor?;
    private readonly maxConcurrent;
    private readonly maxStepTimeoutS;
    private readonly progress;
    constructor(deps: OrchestratorDeps);
    decomposePrompt(prompt: string): DecomposedTask;
    execute(task: DecomposedTask, mode: AutonomyMode): Promise<ExecutionResult>;
    getProgress(taskId: string): TaskProgress | undefined;
    getDecomposer(): TaskDecomposer;
    getProtocol(): CollaborationProtocol;
    private executeStep;
    private buildSuggestResult;
    private buildStepResult;
    private emitStepEvent;
    private stepTypeToActionType;
    private executeWithTimeout;
    private initProgress;
    private updateProgress;
    private finalizeProgress;
}
//# sourceMappingURL=AutonomyOrchestrator.d.ts.map