/**
 * Agentic QE v3 - Protocol Execution Engine
 * Executes cross-domain protocols on schedule or trigger
 */
import { DomainName, DomainEvent, Result } from '../shared/types';
import { EventBus, MemoryBackend } from '../kernel/interfaces';
import { Protocol, ProtocolExecution, ProtocolExecutor } from './interfaces';
export declare class DefaultProtocolExecutor implements ProtocolExecutor {
    private readonly eventBus;
    private readonly memory;
    private readonly getDomainAPI;
    private readonly protocols;
    private readonly executions;
    private readonly scheduledProtocols;
    private schedulerRunning;
    constructor(eventBus: EventBus, memory: MemoryBackend, getDomainAPI: <T>(domain: DomainName) => T | undefined);
    /**
     * Register a protocol
     */
    registerProtocol(protocol: Protocol): void;
    /**
     * Unregister a protocol
     */
    unregisterProtocol(protocolId: string): boolean;
    /**
     * Get registered protocol
     */
    getProtocol(protocolId: string): Protocol | undefined;
    /**
     * List all registered protocols
     */
    listProtocols(): Protocol[];
    /**
     * Execute a protocol immediately
     */
    execute(protocolId: string, params?: Record<string, unknown>): Promise<Result<ProtocolExecution, Error>>;
    /**
     * Execute a protocol triggered by an event
     */
    executeOnEvent(protocolId: string, event: DomainEvent): Promise<Result<ProtocolExecution, Error>>;
    /**
     * Get execution status
     */
    getExecution(executionId: string): ProtocolExecution | undefined;
    /**
     * List active executions
     */
    listActiveExecutions(): ProtocolExecution[];
    /**
     * Cancel an execution
     */
    cancelExecution(executionId: string): Promise<Result<void, Error>>;
    /**
     * Pause an execution
     */
    pauseExecution(executionId: string): Promise<Result<void, Error>>;
    /**
     * Resume a paused execution
     */
    resumeExecution(executionId: string): Promise<Result<void, Error>>;
    /**
     * Start the scheduler for periodic protocol execution
     */
    startScheduler(): void;
    /**
     * Stop the scheduler
     */
    stopScheduler(): void;
    /**
     * Dispose resources
     */
    dispose(): Promise<void>;
    /**
     * Execute a protocol
     */
    private executeProtocol;
    /**
     * Execute protocol actions respecting dependencies
     */
    private executeActions;
    /**
     * Execute a single action
     */
    private executeAction;
    /**
     * Check if all dependencies of an action are satisfied
     */
    private dependenciesSatisfied;
    /**
     * Execute a promise with timeout
     */
    private executeWithTimeout;
    /**
     * Set up event-based triggers for a protocol
     */
    private setupEventTriggers;
    /**
     * Schedule a protocol for periodic execution
     */
    private scheduleProtocol;
    /**
     * Store execution history in memory
     */
    private storeExecutionHistory;
    /**
     * Convert mutable execution to immutable
     */
    private toImmutableExecution;
    /**
     * Publish a coordination event
     */
    private publishEvent;
    /**
     * Sleep helper
     */
    private sleep;
}
export declare function createProtocolExecutor(eventBus: EventBus, memory: MemoryBackend, getDomainAPI: <T>(domain: DomainName) => T | undefined): ProtocolExecutor;
//# sourceMappingURL=protocol-executor.d.ts.map