/**
 * Async Utilities for qtests
 *
 * Provides comprehensive async/await utilities, timeout handling,
 * retry logic, and flow control utilities for async operations.
 */
export interface AsyncOptions {
    timeout?: number;
    retries?: number;
    delay?: number;
    backoff?: boolean;
    maxBackoff?: number;
}
export interface BatchOptions<T> {
    concurrency?: number;
    timeout?: number;
    onSuccess?: (result: T, index: number) => void;
    onError?: (error: Error, index: number) => void;
}
export interface WorkflowStep<T = any> {
    name: string;
    action: (data?: any) => Promise<T>;
    timeout?: number;
    retries?: number;
    dependencies?: string[];
    condition?: (data: any) => boolean;
}
export interface WorkflowResult<T = any> {
    results: Record<string, T>;
    steps: string[];
    duration: number;
    success: boolean;
    errors?: Record<string, Error>;
}
declare const asyncConfig: {
    defaultTimeout: number;
    defaultRetries: number;
    concurrency: number;
    slowThreshold: number;
};
/**
 * Create a timeout promise
 */
export declare const createTimeout: (ms: number, reason?: string) => Promise<never>;
/**
 * Wait for specified time
 */
export declare const wait: (ms: number) => Promise<void>;
/**
 * Execute with timeout
 */
export declare const withTimeout: <T>(operation: () => Promise<T>, timeoutMs: number, reason?: string) => Promise<T>;
/**
 * Execute with retries
 */
export declare const withRetries: <T>(operation: () => Promise<T>, options: AsyncOptions, context: string) => Promise<T>;
/**
 * Execute with timeout and retries
 */
export declare const withTimeoutAndRetries: <T>(operation: () => Promise<T>, options?: AsyncOptions, context?: string) => Promise<T>;
/**
 * Execute multiple operations in parallel
 */
export declare const parallel: <T>(operations: Array<() => Promise<T>>, options?: BatchOptions<T>) => Promise<T[]>;
/**
 * Execute operations sequentially
 */
export declare const sequential: <T>(operations: Array<() => Promise<T>>, context?: string) => Promise<T[]>;
/**
 * Wait for condition to be true
 */
export declare const waitForCondition: (condition: () => boolean | Promise<boolean>, options?: AsyncOptions) => Promise<void>;
/**
 * Execute with callback pattern
 */
export declare const executeWithCallback: <T>(operation: (callback: (error?: Error, result?: T) => void) => void) => Promise<T>;
/**
 * Create debounced function
 */
export declare const debounce: <T extends (...args: any[]) => any>(func: T, delayMs: number) => ((...args: Parameters<T>) => void);
/**
 * Create throttled function
 */
export declare const throttle: <T extends (...args: any[]) => any>(func: T, delayMs: number) => ((...args: Parameters<T>) => void);
/**
 * Execute workflow steps
 */
export declare const executeWorkflow: <T = any>(steps: WorkflowStep<T>[], context?: any) => Promise<WorkflowResult<T>>;
/**
 * Race multiple operations
 */
export declare const race: <T>(operations: Array<() => Promise<T>>, options?: {
    timeout?: number;
}) => Promise<{
    result: T;
    index: number;
    winner: string;
}>;
/**
 * Configure async utilities
 */
export declare const configure: (options: Partial<typeof asyncConfig>) => void;
/**
 * Get current configuration
 */
export declare const getConfig: () => {
    defaultTimeout: number;
    defaultRetries: number;
    concurrency: number;
    slowThreshold: number;
};
export {};
//# sourceMappingURL=asyncUtils.d.ts.map