/**
 * Resilience pattern composition engine
 * Handles middleware chaining and validation for resilience patterns
 */
import type { CompositionOrder } from '@orchestr8/schema';
import type { CircuitBreakerConfig, NormalizedResilienceConfig, ResilienceContext, ResilientOperation, RetryConfig, TimeoutConfig } from './types.js';
/**
 * Middleware function type - wraps an operation with resilience behavior
 */
export type ResilienceMiddleware<T> = (operation: ResilientOperation<T>, context?: ResilienceContext) => Promise<T>;
/**
 * Wrapper function type for individual resilience patterns
 */
export type PatternWrapper<T, C = RetryConfig | CircuitBreakerConfig | TimeoutConfig> = (operation: ResilientOperation<T>, config: C, context?: ResilienceContext) => Promise<T>;
/**
 * Resilience composition engine
 * Validates and composes resilience patterns according to specified order
 */
export declare class ResilienceComposer {
    private retryWrapper?;
    private circuitBreakerWrapper?;
    private timeoutWrapper?;
    /**
     * Set the retry pattern wrapper implementation
     */
    setRetryWrapper<T>(wrapper: PatternWrapper<T, RetryConfig>): void;
    /**
     * Set the circuit breaker pattern wrapper implementation
     */
    setCircuitBreakerWrapper<T>(wrapper: PatternWrapper<T, CircuitBreakerConfig>): void;
    /**
     * Set the timeout pattern wrapper implementation
     */
    setTimeoutWrapper<T>(wrapper: PatternWrapper<T, TimeoutConfig>): void;
    /**
     * Compose resilience patterns into a middleware chain
     * @param config - Normalized resilience configuration
     * @param compositionOrder - The order in which to compose patterns
     * @returns A middleware function that applies all configured patterns
     */
    compose<T>(config: NormalizedResilienceConfig, compositionOrder: CompositionOrder): ResilienceMiddleware<T>;
    /**
     * Validate if a composition order is supported
     */
    private isValidCompositionOrder;
}
/**
 * Default retry wrapper implementation
 */
export declare function defaultRetryWrapper<T>(operation: ResilientOperation<T>, config: RetryConfig, context?: ResilienceContext): Promise<T>;
/**
 * Default timeout wrapper implementation
 */
export declare function defaultTimeoutWrapper<T>(operation: ResilientOperation<T>, config: TimeoutConfig, context?: ResilienceContext): Promise<T>;
/**
 * Default circuit breaker wrapper using CircuitBreaker class
 */
export declare function defaultCircuitBreakerWrapper<T>(operation: ResilientOperation<T>, config: CircuitBreakerConfig, context?: ResilienceContext): Promise<T>;