@akala/core/dist/esm/eachAsync.d.ts

/**
 * Type representing an async iteration callback function.
 * @template TError - Error type
 * @template T - Argument array type
 * @template TReturn - Return type
 */
export type NextFunction<TError = unknown, T extends unknown[] = [], TReturn = void> = (error?: TError, ...args: T) => TReturn;
/**
 * Simplified version of NextFunction for cases without arguments.
 * @template T - Error type
 */
export type SimpleNextFunction<T> = NextFunction<T, [], void | Promise<void>>;
/**
 * Represents an error that aggregates multiple errors from asynchronous iterations.
 * @class
 * @extends {Error}
 * @property {Error[]} errors - The array of errors that occurred during iteration.
 */
export declare class AggregateErrors extends Error {
    readonly errors: Error[];
    constructor(errors: Error[]);
}
/**
 * Asynchronously iterates over elements of an array-like structure.
 * @param {T[] | ArrayLike<T>} array - Array-like structure to iterate over
 * @param {(element: T, i: number) => Promise<void>} body - Async callback executed for each element
 * @param {boolean} waitForPrevious - Whether to wait for previous iteration to complete before next
 * @returns {Promise<void>} Resolves when all iterations complete
 */
export declare function array<T>(array: T[] | ArrayLike<T>, body: (element: T, i: number) => Promise<void>, waitForPrevious: boolean): Promise<void>;
/**
 * Asynchronously iterates over key-value pairs of an object.
 * @param {T} o - Object to iterate over
 * @param {(element: T[keyof T], i: keyof T) => Promise<void>} body - Async callback for each key-value pair
 * @param {boolean} waitForPrevious - Whether to wait for previous iteration to complete
 * @returns {Promise<void>} Resolves when all iterations complete
 */
export declare function object<T, U extends unknown[] = []>(o: T, body: (element: T[keyof T], i: keyof T) => Promise<void>, waitForPrevious: boolean): Promise<void>;
/**
 * Unified async iteration entry point for arrays/objects.
 * @function
 * @param {T[] | ArrayLike<T> | Record<string, unknown>} it - Iterable structure to process
 * @param {(element: unknown, i: any) => Promise<void>} body - Async iteration callback
 * @param {boolean} [waitForPrevious=true] - Whether to wait for previous iteration to complete
 * @returns {Promise<void>} Resolves when all iterations complete
 */
export declare function each<T, TError, U extends unknown[]>(array: T[] | ArrayLike<T>, body: (element: T, i?: number) => Promise<void>, waitForPrevious?: boolean): Promise<void>;
export declare function each<TError, U extends unknown[], T = Record<string, unknown>>(o: T, body: (element: T[typeof i], i: keyof T) => Promise<void>, waitForPrevious?: boolean): Promise<void>;
/**
 * Asynchronously maps elements of an array-like structure to new values.
 * @param {T[] | ArrayLike<T>} it - Array-like structure to process
 * @param {(element: T, i: number) => Promise<U>} body - Async transformation function
 * @param {boolean} waitForPrevious - Whether to wait for previous iteration
 * @returns {Promise<U[]>} Promise resolving to transformed elements
 */
export declare function mapArray<T, U>(it: T[] | ArrayLike<T>, body: (element: T, i: number) => Promise<U>, waitForPrevious: boolean): Promise<U[]>;
/**
 * Asynchronously maps key-value pairs of an object to new values.
 * @param {TIn} o - Source object to process
 * @param {(element: TIn[keyof TIn], i: keyof TIn) => TResultValue} body - Transformation function
 * @param {boolean} asArray - Return results as array instead of object
 * @param {boolean} waitForPrevious - Whether to wait for previous iteration
 * @returns {Promise<TResultValue[] | Partial<Proxy<TIn, TResultValue>>>} Transformed results
 */
export declare function mapObject<TIn, TResultValue>(o: TIn, body: (element: TIn[keyof TIn], i: keyof TIn) => TResultValue, asArray: true, waitForPrevious: boolean): Promise<TResultValue[]>;
export declare function mapObject<TIn, TResultValue>(o: TIn, body: (element: TIn[keyof TIn], i: keyof TIn) => TResultValue, asArray: false, waitForPrevious: boolean): Promise<{
    [P in keyof TIn]?: TResultValue;
}>;
export declare function mapObject<TIn, TResultValue>(o: TIn, body: (element: TIn[keyof TIn], i: keyof TIn) => TResultValue, asArray: boolean, waitForPrevious: boolean): any;
/**
 * Unified async mapping function for arrays/objects.
 * @function
 * @param {T[] | ArrayLike<T> | Record<string, unknown>} it - Iterable structure to process
 * @param {(element: any, i: any) => any} body - Async mapping function
 * @param {boolean} [asArray=false] - Return results as array
 * @param {boolean} [waitForPrevious=true] - Whether to wait between iterations
 * @returns {Promise<any>} Transformed results based on input type
 */
export declare function map<T, U>(array: T[] | ArrayLike<T>, body: (element: T, i: number) => Promise<U>, asArray: true, waitForPrevious?: boolean): Promise<U[]>;
export declare function map<T, U>(array: T[] | ArrayLike<T>, body: (element: T, i: number) => Promise<U>, asArray: boolean, waitForPrevious?: boolean): Promise<U[]>;
export declare function map<TIn, TKey extends keyof TIn, TResultValue>(o: TIn, body: (element: TIn[TKey], i: TKey) => Promise<TResultValue>, asArray?: false, waitForPrevious?: boolean): Promise<Proxy<TIn, TResultValue>>;
export declare function map<TIn, TKey extends keyof TIn, TResultValue>(o: TIn, body: (element: TIn[TKey], i: TKey) => Promise<TResultValue>, asArray: true, waitForPrevious?: boolean): Promise<TResultValue[]>;
/**
 * Asynchronously filters elements of an array-like structure.
 * @param {T[] | ArrayLike<T>} it - Array-like structure to filter
 * @param {(element: T, i: number) => Promise<boolean>} body - Async predicate function
 * @param {boolean} waitForPrevious - Whether to wait for previous iteration
 * @returns {Promise<T[]>} Filtered elements
 */
export declare function grepArray<T>(it: T[] | ArrayLike<T>, body: (element: T, i: number) => Promise<boolean>, waitForPrevious: boolean): Promise<T[]>;
export type Proxy<T, U> = {
    [P in keyof T]: U;
};
/**
 * Asynchronously filters key-value pairs of an object.
 * @param {T} o - Object to filter
 * @param {(element: T[keyof T], i: keyof T) => Promise<boolean>} body - Async predicate function
 * @param {boolean} asArray - Return results as array
 * @param {boolean} waitForPrevious - Whether to wait for previous iteration
 * @returns {Promise<T[keyof T][] | Partial<T>>} Filtered results
 */
export declare function grepObject<T>(o: T, body: (element: T[keyof T], i: keyof T) => Promise<boolean>, asArray: true, waitForPrevious: boolean): Promise<T[keyof T][]>;
export declare function grepObject<T>(o: T, body: (element: T[keyof T], i: keyof T) => Promise<boolean>, asArray: false, waitForPrevious: boolean): Promise<Partial<T>>;
export declare function grepObject<T>(o: T, body: (element: T[keyof T], i: keyof T) => Promise<boolean>, asArray: boolean, waitForPrevious: boolean): Promise<Partial<T> | T[keyof T][]>;
/**
 * Unified async filter function for arrays/objects.
 * @function
 * @param {T[] | ArrayLike<T> | Record<string, unknown>} it - Iterable structure to process
 * @param {(element: any, i: any) => Promise<boolean>} body - Async predicate function
 * @param {boolean} [asArray=false] - Return results as array
 * @param {boolean} [waitForPrevious=true] - Whether to wait between iterations
 * @returns {Promise<any>} Filtered results based on input type
 */
export declare function grep<T>(array: T[] | ArrayLike<T>, body: (element: T, i: number) => Promise<boolean>, waitForPrevious?: boolean): Promise<T[]>;
export declare function grep<T>(o: T, body: <U extends keyof T>(element: T[U], i: U) => Promise<boolean>, waitForPrevious?: boolean): Promise<Partial<T>>;
export declare function grep<T, U extends keyof T>(o: T, body: (element: T[U], i: U) => Promise<boolean>, asArray: true, waitForPrevious?: boolean): Promise<T[U][]>;