/**
 * Compensation Manager for Saga pattern
 *
 * Features:
 * - Automatic compensation on failure
 * - Reverse-order execution
 * - Partial compensation (only completed steps)
 * - Compensation condition checking
 * - Compensation result tracking
 */
import type { CompensationConfig, CompensationOrder, WorkflowState } from '@cogitator-ai/types';
/**
 * Compensation step definition
 */
export interface CompensationStep<S = WorkflowState> {
    nodeId: string;
    compensationFn: (state: S, originalResult: unknown) => Promise<void>;
    condition?: (state: S, error: Error) => boolean;
    order?: CompensationOrder;
    timeout?: number;
    retries?: number;
}
/**
 * Compensation execution result
 */
export interface CompensationResult {
    nodeId: string;
    success: boolean;
    error?: Error;
    duration: number;
    skipped: boolean;
    skipReason?: string;
}
/**
 * Full compensation execution report
 */
export interface CompensationReport {
    triggeredBy: {
        nodeId: string;
        error: Error;
    };
    compensated: CompensationResult[];
    totalDuration: number;
    allSuccessful: boolean;
    partialFailures: string[];
}
/**
 * Compensation Manager class
 */
export declare class CompensationManager<S = WorkflowState> {
    private steps;
    private completedNodes;
    private executionOrder;
    /**
     * Register a compensation step for a node
     */
    registerCompensation(nodeId: string, compensationFn: (state: S, originalResult: unknown) => Promise<void>, options?: Partial<Omit<CompensationStep<S>, 'nodeId' | 'compensationFn'>>): void;
    /**
     * Register compensation from config
     */
    registerFromConfig(nodeId: string, config: CompensationConfig<S>): void;
    /**
     * Mark a node as completed with its result
     */
    markCompleted(nodeId: string, result: unknown): void;
    /**
     * Clear a node's completion status (for retries)
     */
    clearCompleted(nodeId: string): void;
    /**
     * Check if a node has a compensation step
     */
    hasCompensation(nodeId: string): boolean;
    /**
     * Get nodes that need compensation (completed nodes with compensation steps)
     */
    getCompensableNodes(): string[];
    /**
     * Execute compensation for all completed nodes
     */
    compensate(state: S, failedNodeId: string, error: Error): Promise<CompensationReport>;
    /**
     * Build ordered compensation groups respecting execution order.
     * Consecutive parallel nodes are grouped and run concurrently at their
     * correct position. Forward-order nodes run individually in forward order.
     */
    private buildCompensationGroups;
    private delay;
    /**
     * Execute with timeout
     */
    private withTimeout;
    /**
     * Reset manager state
     */
    reset(): void;
    /**
     * Get current state summary
     */
    getSummary(): CompensationManagerSummary;
}
/**
 * Compensation manager summary
 */
export interface CompensationManagerSummary {
    registeredSteps: number;
    completedNodes: number;
    compensableNodes: number;
    executionOrder: string[];
}
/**
 * Create a compensation manager
 */
export declare function createCompensationManager<S = WorkflowState>(): CompensationManager<S>;
/**
 * Compensation builder for fluent API
 */
export declare class CompensationBuilder<S = WorkflowState> {
    private steps;
    /**
     * Add a compensation step
     */
    addStep(nodeId: string, fn: (state: S, result: unknown) => Promise<void>, options?: Partial<Omit<CompensationStep<S>, 'nodeId' | 'compensationFn'>>): this;
    /**
     * Add conditional compensation
     */
    addConditionalStep(nodeId: string, fn: (state: S, result: unknown) => Promise<void>, condition: (state: S, error: Error) => boolean, options?: Partial<Omit<CompensationStep<S>, 'nodeId' | 'compensationFn' | 'condition'>>): this;
    /**
     * Build the compensation manager
     */
    build(): CompensationManager<S>;
}
/**
 * Create a compensation builder
 */
export declare function compensationBuilder<S = WorkflowState>(): CompensationBuilder<S>;
//# sourceMappingURL=compensation.d.ts.map