async-ray/dist/async_array.d.ts

Allow perform every, filter, find, findIndex, forEach, map, reduce, reduceRight and some on array using Async callback

import * as Methods from './methods';
/**
 * AsyncArray Class
 *
 * @class AsyncArray
 * @extends {Array<T>}
 * @template T
 */
export declare class AsyncArray<T> extends Array<T> {
    /**
     * Creates an instance of AsyncArray
     * @param {...T[]} args
     * @memberof AsyncArray
     */
    constructor(...args: T[]);
    /**
     * Async Every method
     *
     * @param {Methods.CallBackFilter<T>} cb
     * @returns {Promise<boolean>}
     * @memberof AsyncArray
     */
    aEvery(cb: Methods.CallBackFilter<T>): Promise<boolean>;
    /**
     * Async FlatMap method
     *
     * @template R
     * @param {Methods.CallBackFlatMap<T, R>} cb
     * @returns {Promise<R[]>}
     * @memberof AsyncArray
     */
    aFlatMap<R>(cb: Methods.CallBackFlatMap<T, R>): Promise<AsyncArray<R>>;
    /**
     * Async Filter method
     *
     * @param {Methods.CallBackFilter<T>} cb
     * @returns {Promise<T[]>}
     * @memberof AsyncArray
     */
    aFilter(cb: Methods.CallBackFilter<T>): Promise<AsyncArray<T>>;
    /**
     * Async find method
     *
     * @param {Methods.CallBackFind<T>} cb
     * @returns {Promise<T | undefined>}
     * @memberof AsyncArray
     */
    aFind(cb: Methods.CallBackFind<T>): Promise<T | undefined>;
    /**
     * Async findIndex method
     *
     * @param {Methods.CallBackFindIndex<T>} cb
     * @returns {Promise<number>}
     * @memberof AsyncArray
     */
    aFindIndex(cb: Methods.CallBackFindIndex<T>): Promise<number>;
    /**
     * Async ForEach method
     *
     * @param {Methods.CallBackForEach<T>} cb
     * @returns {Promise<void>}
     * @memberof AsyncArray
     */
    aForEach(cb: Methods.CallBackForEach<T>): Promise<void>;
    /**
     * Async Map method
     *
     * @template R
     * @param {Methods.CallBackMap<T, R>} cb
     * @returns {Promise<R[]>}
     * @memberof AsyncArray
     */
    aMap<R>(cb: Methods.CallBackMap<T, R>): Promise<AsyncArray<R>>;
    /**
     * Async Reduce method
     *
     * @template R
     * @param {Methods.CallBackReduce<T, R>} cb
     * @param {R} [initialValue]
     * @returns {Promise<T | R>}
     * @memberof AsyncArray
     */
    aReduce<R>(cb: Methods.CallBackReduce<T, R>, initialValue?: R): Promise<T | R>;
    /**
     * Async ReduceRight method
     *
     * @template R
     * @param {Methods.CallBackReduceRight<T, R>} cb
     * @param {R} [initialValue]
     * @returns {Promise<T | R>}
     * @memberof AsyncArray
     */
    aReduceRight<R>(cb: Methods.CallBackReduceRight<T, R>, initialValue?: R): Promise<T | R>;
    /**
     * Async Some method
     *
     * @param {Methods.CallBackFilter<T>} cb
     * @returns {Promise<boolean>}
     * @memberof AsyncArray
     */
    aSome(cb: Methods.CallBackFilter<T>): Promise<boolean>;
}