/**
 * MaybePromise utilities for transparent async support.
 *
 * The sync path stays zero-overhead — when no async JS functions are involved,
 * everything runs synchronously with only `instanceof Promise` checks as overhead.
 * When an async value is detected, the evaluation chain switches to Promise-based
 * execution for the remainder.
 */
export type MaybePromise<T> = T | Promise<T>;
/**
 * Chain a value that might be a Promise. If the value is sync, calls fn synchronously.
 * If it's a Promise, chains with .then().
 */
export declare function chain<T, U>(value: MaybePromise<T>, fn: (v: T) => MaybePromise<U>): MaybePromise<U>;
/**
 * Like Array.map but handles MaybePromise callbacks sequentially.
 * In the sync case, runs as a simple loop. Switches to async only when needed.
 */
export declare function mapSequential<T, U>(arr: readonly T[], fn: (elem: T, index: number) => MaybePromise<U>): MaybePromise<U[]>;
/**
 * Like Array.reduce but handles MaybePromise callbacks sequentially.
 * In the sync case, runs as a simple loop. Switches to async only when needed.
 */
export declare function reduceSequential<T, U>(arr: readonly T[], fn: (acc: U, elem: T, index: number) => MaybePromise<U>, initial: U): MaybePromise<U>;
/**
 * Like Array.forEach but handles MaybePromise callbacks sequentially.
 * In the sync case, runs as a simple loop. Switches to async only when needed.
 */
export declare function forEachSequential<T>(arr: readonly T[], fn: (elem: T, index: number) => MaybePromise<void>): MaybePromise<void>;
/**
 * Try/catch that handles MaybePromise values correctly.
 * If tryFn returns a Promise, catches both sync throws and Promise rejections.
 */
export declare function tryCatch<T>(tryFn: () => MaybePromise<T>, catchFn: (error: unknown) => MaybePromise<T>): MaybePromise<T>;
/**
 * Like Array.some but handles MaybePromise callbacks sequentially.
 * Returns the first truthy MaybePromise result, or false.
 */
export declare function someSequential<T>(arr: readonly T[], fn: (elem: T, index: number) => MaybePromise<unknown>): MaybePromise<boolean>;
/**
 * Like Array.every but handles MaybePromise callbacks sequentially.
 * Returns false as soon as a falsy result is found.
 */
export declare function everySequential<T>(arr: readonly T[], fn: (elem: T, index: number) => MaybePromise<unknown>): MaybePromise<boolean>;
/**
 * Like Array.filter but handles MaybePromise callbacks sequentially.
 * Returns the filtered array.
 */
export declare function filterSequential<T>(arr: readonly T[], fn: (elem: T, index: number) => MaybePromise<unknown>): MaybePromise<T[]>;
/**
 * Like Array.findIndex but handles MaybePromise callbacks sequentially.
 * Returns -1 if no element matches.
 */
export declare function findIndexSequential<T>(arr: readonly T[], fn: (elem: T, index: number) => MaybePromise<unknown>): MaybePromise<number>;