/**
 * Saga Pattern - Distributed transaction orchestration with compensation
 */
import { Logger } from "../types/common";
import { SagaOptions, SagaResult, SagaStep } from "../types/saga";
/**
 * Internal options for saga execution (without context and steps)
 */
interface SagaInternalOptions<TContext = any> {
    logger?: Logger;
    onStepStart?: (stepName: string, index: number) => void;
    onStepComplete?: (stepName: string, result: unknown) => void;
    onStepFailed?: (stepName: string, error: Error) => void;
    onCompensate?: (stepName: string) => void;
    onComplete?: (context: TContext) => void;
    onFailure?: (error: Error, context: TContext) => void;
}
/**
 * Saga - Distributed transaction orchestrator
 */
export declare class Saga<TContext = any> {
    private steps;
    private context;
    private logger;
    private options;
    constructor(initialContext: TContext, options?: SagaInternalOptions<TContext>);
    /**
     * Add a step to the saga
     */
    addStep(step: SagaStep<TContext>): this;
    /**
     * Add multiple steps
     */
    addSteps(steps: SagaStep<TContext>[]): this;
    /**
     * Execute the saga
     */
    execute(): Promise<SagaResult<TContext>>;
    /**
     * Compensate executed steps (in reverse order)
     */
    private compensate;
    /**
     * Execute function with timeout
     */
    private executeWithTimeout;
    /**
     * Get current context
     */
    getContext(): TContext;
    /**
     * Update context
     */
    updateContext(updates: Partial<TContext>): void;
}
/**
 * Execute a saga with single parameter API
 */
export declare function executeSaga<TContext>(options: SagaOptions<TContext>): Promise<SagaResult<TContext>>;
export {};
//# sourceMappingURL=saga.d.ts.map