/**
 * @file Async Utilities
 * @description Common async/promise utilities for the application
 */
/**
 * Deferred promise interface
 */
export interface Deferred<T> {
    promise: Promise<T>;
    resolve: (value: T | PromiseLike<T>) => void;
    reject: (reason?: unknown) => void;
}
/**
 * Create a deferred promise
 */
export declare function defer<T = void>(): Deferred<T>;
/**
 * Delay execution for a specified time
 */
export declare function delay(ms: number): Promise<void>;
/**
 * Wait for a condition to be true
 */
export declare function waitFor(condition: () => boolean | Promise<boolean>, options?: {
    timeout?: number;
    interval?: number;
}): Promise<void>;
/**
 * Retry a function with exponential backoff
 */
export declare function retry<T>(fn: () => Promise<T>, options?: {
    maxAttempts?: number;
    delayMs?: number;
    maxDelayMs?: number;
    backoffMultiplier?: number;
    onRetry?: (error: Error, attempt: number) => void;
}): Promise<T>;
/**
 * Run promises with a concurrency limit
 */
export declare function concurrent<T, R>(items: T[], fn: (item: T, index: number) => Promise<R>, concurrency?: number): Promise<R[]>;
/**
 * Timeout wrapper for promises
 */
export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message?: string): Promise<T>;
/**
 * Create a debounced async function
 */
export declare function debounceAsync<T extends (...args: unknown[]) => Promise<unknown>>(fn: T, delayMs: number): T;
/**
 * Create a throttled async function
 */
export declare function throttleAsync<T extends (...args: unknown[]) => Promise<unknown>>(fn: T, intervalMs: number): T;
/**
 * Execute a function and return a tuple of [error, result]
 */
export declare function tryCatch<T>(fn: () => Promise<T>): Promise<[Error, null] | [null, T]>;
/**
 * Create a cancelable promise
 */
export interface CancelablePromise<T> {
    promise: Promise<T>;
    cancel: () => void;
    isCanceled: () => boolean;
}
export declare function makeCancelable<T>(promise: Promise<T>): CancelablePromise<T>;
/**
 * Run async functions in sequence
 */
export declare function sequence<T>(fns: Array<() => Promise<T>>): Promise<T[]>;
/**
 * Create a semaphore for limiting concurrent operations
 */
export declare function createSemaphore(limit: number): {
    acquire: () => Promise<void>;
    release: () => void;
    available: number;
    waiting: number;
};