import { GatewayRequest, GatewayResponse } from './api-gateway';
/**
 * Request definition for orchestration.
 */
export interface OrchestratedRequest<T = unknown> {
    /** Unique request identifier */
    id: string;
    /** The request to execute */
    request: GatewayRequest | (() => Promise<T>);
    /** Dependencies (other request IDs that must complete first) */
    dependsOn?: string[];
    /** Transform the result before storing */
    transform?: (result: T) => unknown;
    /** Condition to determine if request should execute */
    condition?: (results: Record<string, unknown>) => boolean;
    /** Custom error handler */
    onError?: (error: Error, results: Record<string, unknown>) => T | Promise<T>;
    /** Priority (higher executes first when dependencies are equal) */
    priority?: number;
    /** Request metadata */
    metadata?: Record<string, unknown>;
}
/**
 * Orchestration result.
 */
export interface OrchestrationResult<T extends Record<string, unknown>> {
    /** Whether all requests succeeded */
    success: boolean;
    /** Results keyed by request ID */
    results: T;
    /** Errors keyed by request ID */
    errors: Record<string, Error>;
    /** Execution order */
    executionOrder: string[];
    /** Total duration in milliseconds */
    duration: number;
    /** Individual request durations */
    durations: Record<string, number>;
}
/**
 * Batch request configuration.
 */
export interface BatchConfig {
    /** Maximum concurrent requests */
    maxConcurrency?: number;
    /** Stop on first error */
    stopOnError?: boolean;
    /** Delay between batches in milliseconds */
    batchDelay?: number;
    /** Timeout for entire batch in milliseconds */
    timeout?: number;
}
/**
 * Chain configuration.
 */
export interface ChainConfig {
    /** Stop chain on error */
    stopOnError?: boolean;
    /** Delay between requests in milliseconds */
    delay?: number;
    /** Pass result to next request */
    passResult?: boolean;
}
/**
 * Waterfall step.
 */
export interface WaterfallStep<TInput, TOutput> {
    /** Step identifier */
    id: string;
    /** Execute function */
    execute: (input: TInput, context: WaterfallContext) => Promise<TOutput>;
    /** Condition to skip step */
    skip?: (input: TInput, context: WaterfallContext) => boolean;
    /** Error handler */
    onError?: (error: Error, input: TInput, context: WaterfallContext) => TOutput | Promise<TOutput>;
}
/**
 * Waterfall execution context.
 */
export interface WaterfallContext {
    /** All results so far */
    results: Record<string, unknown>;
    /** Original input */
    originalInput: unknown;
    /** Metadata */
    metadata: Record<string, unknown>;
}
/**
 * Request Orchestrator for complex API request patterns.
 *
 * @example
 * ```typescript
 * const orchestrator = new RequestOrchestrator(apiGateway.request.bind(apiGateway));
 *
 * // Parallel requests
 * const results = await orchestrator.parallel([
 *   { path: '/users', method: 'GET' },
 *   { path: '/posts', method: 'GET' },
 *   { path: '/comments', method: 'GET' },
 * ]);
 *
 * // Dependent requests
 * const orchestrated = await orchestrator.orchestrate([
 *   { id: 'user', request: { path: '/users/1', method: 'GET' } },
 *   {
 *     id: 'posts',
 *     request: { path: '/posts?userId=1', method: 'GET' },
 *     dependsOn: ['user'],
 *   },
 * ]);
 * ```
 */
export declare class RequestOrchestrator {
    private readonly executor;
    /**
     * Create a new orchestrator.
     *
     * @param executor - Function to execute requests
     */
    constructor(executor: <T>(request: GatewayRequest) => Promise<GatewayResponse<T>>);
    /**
     * Execute multiple requests in parallel.
     *
     * @param requests - Requests to execute
     * @param config - Batch configuration
     * @returns Array of results
     */
    parallel<T = unknown>(requests: GatewayRequest[], config?: BatchConfig): Promise<GatewayResponse<T>[]>;
    /**
     * Execute requests in parallel, settling all regardless of errors.
     *
     * @param requests - Requests to execute
     * @returns Results and errors
     */
    allSettled<T = unknown>(requests: GatewayRequest[]): Promise<{
        fulfilled: GatewayResponse<T>[];
        rejected: {
            request: GatewayRequest;
            error: Error;
        }[];
    }>;
    /**
     * Race multiple requests, returning the first to complete.
     *
     * @param requests - Requests to race
     * @returns First completed result
     */
    race<T = unknown>(requests: GatewayRequest[]): Promise<GatewayResponse<T>>;
    /**
     * Execute requests sequentially.
     *
     * @param requests - Requests to execute in order
     * @param config - Chain configuration
     * @returns Array of results
     */
    sequence<T = unknown>(requests: GatewayRequest[], config?: ChainConfig): Promise<GatewayResponse<T>[]>;
    /**
     * Execute a waterfall pattern where each step's output feeds the next.
     *
     * @param steps - Waterfall steps
     * @param initialInput - Initial input to first step
     * @returns Final result and all intermediate results
     */
    waterfall<TInput, TOutput>(steps: WaterfallStep<unknown, unknown>[], initialInput: TInput): Promise<{
        result: TOutput;
        results: Record<string, unknown>;
    }>;
    /**
     * Orchestrate requests with dependencies.
     *
     * Requests are executed in optimal order based on their dependencies,
     * maximizing parallelism while respecting dependency constraints.
     *
     * @param requests - Orchestrated requests
     * @returns Orchestration result
     */
    orchestrate<T extends Record<string, unknown>>(requests: OrchestratedRequest[]): Promise<OrchestrationResult<T>>;
    /**
     * Execute with fallback options.
     *
     * @param primary - Primary request
     * @param fallbacks - Fallback requests in order of preference
     * @returns First successful result
     */
    withFallback<T = unknown>(primary: GatewayRequest, fallbacks: GatewayRequest[]): Promise<GatewayResponse<T>>;
    /**
     * Execute with retry and exponential backoff.
     *
     * @param request - Request to execute
     * @param maxRetries - Maximum retry attempts
     * @param baseDelay - Base delay in milliseconds
     * @returns Response
     */
    withRetry<T = unknown>(request: GatewayRequest, maxRetries?: number, baseDelay?: number): Promise<GatewayResponse<T>>;
    /**
     * Execute with timeout.
     *
     * @param request - Request to execute
     * @param timeout - Timeout in milliseconds
     * @returns Response
     */
    withTimeout<T = unknown>(request: GatewayRequest, timeout: number): Promise<GatewayResponse<T>>;
    /**
     * Aggregate paginated results.
     *
     * @param baseRequest - Base request
     * @param options - Pagination options
     * @returns All aggregated results
     */
    paginate<T = unknown>(baseRequest: GatewayRequest, options?: {
        /** Page parameter name */
        pageParam?: string;
        /** Limit parameter name */
        limitParam?: string;
        /** Items per page */
        pageSize?: number;
        /** Maximum pages to fetch */
        maxPages?: number;
        /** Extract items from response */
        getItems?: (data: unknown) => T[];
        /** Check if more pages exist */
        hasMore?: (data: unknown, page: number) => boolean;
    }): Promise<T[]>;
    /**
     * Build dependency graph and determine execution levels.
     */
    private buildDependencyGraph;
    /**
     * Delay execution.
     */
    private delay;
}
/**
 * Create a new request orchestrator.
 *
 * @param executor - Request executor function
 * @returns RequestOrchestrator instance
 */
export declare function createRequestOrchestrator(executor: <T>(request: GatewayRequest) => Promise<GatewayResponse<T>>): RequestOrchestrator;