import pMapFn from 'p-map';
/**
 * Create an iterable by the range
 * @param start - Stating index (inclusive)
 * @param end - Ending index (exclusive)
 * @param step - Step
 * @returns
 */
export declare function iterateByRange(start?: number, end?: number, step?: number): Iterable<number>;
/**
 * Create an iterable by the limit and offset
 * @param limit - Limit
 * @param offset - Offset
 * @returns
 */
export declare function iterateByLimit(limit: number, offset?: number): Iterable<number>;
/**
 * Options for paginated p-map
 */
export type PMapByPageOptions = pMapFn.Options & {
    pageSize?: number;
};
/**
 * Map a large list asynchronously with pagination
 * @param input - A large list of items
 * @param mapper - Mapping function
 * @param options - Options for mapping, including `concurrency` and `pageSize`
 * @returns
 */
export declare function pMapByPage<T = unknown, N = unknown>(input: Iterable<T>, mapper: pMapFn.Mapper<T[], N>, options?: PMapByPageOptions): Promise<N[]>;
/**
 * Map a large collection asynchronously with pagination (start, end)
 * @param range - Size of the collection
 * @param mapper - Mapping function that handles a range (start, end)
 * @param options - Options for mapping, including `concurrency` and `pageSize`
 * @returns
 */
export declare function pMapByRange<N = unknown>(range: number | [number, number], mapper: pMapFn.Mapper<{
    start: number;
    end: number;
}, N>, options?: PMapByPageOptions): Promise<N[]>;
/**
 * Map a large collection asynchronously with pagination (offset, limit)
 * @param size - Size of the collection
 * @param mapper - Mapping function that handles a page (offset, limit)
 * @param options - Options for mapping, including `concurrency` and `pageSize`
 * @returns
 */
export declare function pMapByPageOffsetAndLimit<N = unknown>(size: number, mapper: pMapFn.Mapper<{
    offset: number;
    limit: number;
}, N>, options?: PMapByPageOptions): Promise<N[]>;
export declare function mapByKeyValue<T, V = T>(items: T[], getKey: (item: T) => string | {
    key: string;
    value: V;
}): Record<string, V[]>;
export declare function pMap<Element, NewElement>(input: Iterable<Element>, mapper: pMapFn.Mapper<Element, NewElement>, options?: pMapFn.Options): Promise<NewElement[]>;
export declare namespace pMap {
    type Options = pMapFn.Options;
    type Mapper = pMapFn.Mapper;
}
export interface AsyncFetchOptions<VALUE, STATE, SUMMARY = undefined> {
    next: (state?: STATE) => Promise<{
        state?: STATE;
        value?: VALUE;
        done?: boolean;
    }>;
    initialState?: STATE;
    reduce?: (prev: SUMMARY | undefined, current: VALUE) => SUMMARY;
    initialSummary?: SUMMARY;
}
/**
 * Async iterator to fetch items from a collection asynchronously
 * @param options - Options to fetch next item
 * @returns
 */
export declare function fetchIterator<VALUE, STATE, SUMMARY = undefined>(options: AsyncFetchOptions<VALUE, STATE, SUMMARY>): AsyncGenerator<Awaited<NonNullable<VALUE>>, Awaited<SUMMARY> | undefined, unknown>;
export interface AsyncFetchByPageOptions<VALUE, STATE> {
    next: (state?: STATE) => Promise<{
        state?: STATE;
        value?: VALUE[];
        done?: boolean;
    }>;
    initialState?: STATE;
}
/**
 * Fetch items by page asynchronously and return items one by one
 * @param options - Options to fetch next page
 * @returns
 */
export declare function fetchIteratorByPage<VALUE, STATE>(options: AsyncFetchByPageOptions<VALUE, STATE>): AsyncGenerator<Awaited<VALUE>, void, unknown>;
/**
 * Fetch items by page asynchronously and return items by page
 * @param options - Options to fetch next page
 * @returns
 */
export declare function fetchIteratorByBatch<VALUE, STATE>(options: AsyncFetchByPageOptions<VALUE, STATE>): AsyncGenerator<VALUE[], void, unknown>;
/**
 * Process items from an async iterator by page
 * @param input - Async iterator
 * @param mapper - Mapping function
 * @param options - Options
 * @returns
 */
export declare function pMapByAsyncIterator<T = unknown, N = unknown>(input: AsyncIterable<T>, mapper: pMapFn.Mapper<T[], N>, options?: PMapByPageOptions): Promise<N[]>;