@types/async 3.2.19 → 3.2.21

async/README.md

@@ -8,9 +8,9 @@ This package contains type definitions for Async (https://github.com/caolan/asyn
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/async.
 
 ### Additional Details
- * Last updated: Fri, 21 Apr 2023 10:02:48 GMT
+ * Last updated: Fri, 22 Sep 2023 18:11:04 GMT
  * Dependencies: none
  * Global values: `async`
 
 # Credits
-These definitions were written by [Boris Yankov](https://github.com/borisyankov), [Arseniy Maximov](https://github.com/kern0), [Joe Herman](https://github.com/Penryn), [Angus Fenying](https://github.com/fenying), [Pascal Martin](https://github.com/pascalmartin), [Etienne Rossignon](https://github.com/erossignon), [Lifeng Zhu](https://github.com/Juliiii), [Tümay Çeber](https://github.com/brendtumi), and [Andrew Pensinger](https://github.com/apnsngr).
+These definitions were written by [Boris Yankov](https://github.com/borisyankov), [Arseniy Maximov](https://github.com/kern0), [Angus Fenying](https://github.com/fenying), [Pascal Martin](https://github.com/pascalmartin), [Etienne Rossignon](https://github.com/erossignon), [Lifeng Zhu](https://github.com/Juliiii), [Tümay Çeber](https://github.com/brendtumi), and [Andrew Pensinger](https://github.com/apnsngr).

async/index.d.ts

@@ -2,7 +2,6 @@
 // Project: https://github.com/caolan/async, https://caolan.github.io/async
 // Definitions by: Boris Yankov <https://github.com/borisyankov>
 //                 Arseniy Maximov <https://github.com/kern0>
-//                 Joe Herman <https://github.com/Penryn>
 //                 Angus Fenying <https://github.com/fenying>
 //                 Pascal Martin <https://github.com/pascalmartin>
 //                 Etienne Rossignon <https://github.com/erossignon>
@@ -14,32 +13,72 @@
 
 export as namespace async;
 
-export interface Dictionary<T> { [key: string]: T; }
+export interface Dictionary<T> {
+    [key: string]: T;
+}
 export type IterableCollection<T> = T[] | IterableIterator<T> | AsyncIterable<T> | Dictionary<T>;
 
-export interface ErrorCallback<E = Error> { (err?: E | null): void; }
-export interface AsyncBooleanResultCallback<E = Error> { (err?: E | null, truthValue?: boolean): void; }
-export interface AsyncResultCallback<T, E = Error> { (err?: E | null, result?: T): void; }
-export interface AsyncResultArrayCallback<T, E = Error> { (err?: E | null, results?: Array<T | undefined>): void; }
-export interface AsyncResultObjectCallback<T, E = Error> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
-export interface AsyncResultRestCallback<T, E = Error> { (err?: E | null, ...results: T[]): void; }
-
-export interface AsyncFunction<T, E = Error> { (callback: (err?: E | null, result?: T) => void): void; }
-export interface AsyncFunctionEx<T, E = Error> { (callback: (err?: E | null, ...results: T[]) => void): void; }
-export interface AsyncIterator<T, E = Error> { (item: T, callback: ErrorCallback<E>): void; }
-export interface AsyncForEachOfIterator<T, E = Error> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
-export interface AsyncResultIterator<T, R, E = Error> { (item: T, callback: AsyncResultCallback<R, E>): void; }
-export interface AsyncResultIteratorPromise<T, R> { (item: T): Promise<R>; }
-export interface AsyncMemoIterator<T, R, E = Error> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
-export interface AsyncBooleanIterator<T, E = Error> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
-
-export interface AsyncWorker<T, E = Error> { (task: T, callback: ErrorCallback<E>): void; }
-export interface AsyncVoidFunction<E = Error> { (callback: ErrorCallback<E>): void; }
+export interface ErrorCallback<E = Error> {
+    (err?: E | null): void;
+}
+export interface AsyncBooleanResultCallback<E = Error> {
+    (err?: E | null, truthValue?: boolean): void;
+}
+export interface AsyncResultCallback<T, E = Error> {
+    (err?: E | null, result?: T): void;
+}
+export interface AsyncResultArrayCallback<T, E = Error> {
+    (err?: E | null, results?: Array<T | undefined>): void;
+}
+export interface AsyncResultObjectCallback<T, E = Error> {
+    (err: E | undefined, results: Dictionary<T | undefined>): void;
+}
+export interface AsyncResultRestCallback<T, E = Error> {
+    (err?: E | null, ...results: T[]): void;
+}
+
+export interface AsyncFunction<T, E = Error> {
+    (callback: (err?: E | null, result?: T) => void): void;
+}
+export interface AsyncFunctionEx<T, E = Error> {
+    (callback: (err?: E | null, ...results: T[]) => void): void;
+}
+export interface AsyncIterator<T, E = Error> {
+    (item: T, callback: ErrorCallback<E>): void;
+}
+export interface AsyncForEachOfIterator<T, E = Error> {
+    (item: T, key: number | string, callback: ErrorCallback<E>): void;
+}
+export interface AsyncResultIterator<T, R, E = Error> {
+    (item: T, callback: AsyncResultCallback<R, E>): void;
+}
+export interface AsyncResultIteratorPromise<T, R> {
+    (item: T): Promise<R>;
+}
+export interface AsyncMemoIterator<T, R, E = Error> {
+    (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void;
+}
+export interface AsyncBooleanIterator<T, E = Error> {
+    (item: T, callback: AsyncBooleanResultCallback<E>): void;
+}
+
+export interface AsyncWorker<T, E = Error> {
+    (task: T, callback: ErrorCallback<E>): void;
+}
+export interface AsyncVoidFunction<E = Error> {
+    (callback: ErrorCallback<E>): void;
+}
 
 export type AsyncAutoTasks<R extends Dictionary<any>, E> = { [K in keyof R]: AsyncAutoTask<R[K], R, E> };
-export type AsyncAutoTask<R1, R extends Dictionary<any>, E> = AsyncAutoTaskFunctionWithoutDependencies<R1, E> | Array<keyof R | AsyncAutoTaskFunction<R1, R, E>>;
-export interface AsyncAutoTaskFunctionWithoutDependencies<R1, E = Error> { (cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
-export interface AsyncAutoTaskFunction<R1, R extends Dictionary<any>, E = Error> { (results: R, cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
+export type AsyncAutoTask<R1, R extends Dictionary<any>, E> =
+    | AsyncAutoTaskFunctionWithoutDependencies<R1, E>
+    | Array<keyof R | AsyncAutoTaskFunction<R1, R, E>>;
+export interface AsyncAutoTaskFunctionWithoutDependencies<R1, E = Error> {
+    (cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void;
+}
+export interface AsyncAutoTaskFunction<R1, R extends Dictionary<any>, E = Error> {
+    (results: R, cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void;
+}
 
 export interface DataContainer<T> {
     data: T;
@@ -212,7 +251,7 @@ export interface QueueObject<T> {
  * - The `unshift` method was removed.
  */
 // FIXME: can not use Omit due to ts version restriction. Replace Pick with Omit, when ts 3.5+ will be allowed
-export interface AsyncPriorityQueue<T> extends Pick<QueueObject<T>, Exclude<keyof QueueObject<T>, 'push' | 'unshift'>> {
+export interface AsyncPriorityQueue<T> extends Pick<QueueObject<T>, Exclude<keyof QueueObject<T>, "push" | "unshift">> {
     push<R>(task: T | T[], priority?: number): Promise<R>;
     push<R, E = Error>(task: T | T[], priority: number, callback: AsyncResultCallback<R, E>): void;
 }
@@ -230,178 +269,343 @@ export type AsyncQueue<T> = QueueObject<T>;
 export type AsyncCargoQueue<T = any> = QueueObject<T>;
 
 // Collections
-export function each<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>, callback: ErrorCallback<E>): void;
+export function each<T, E = Error>(
+    arr: IterableCollection<T>,
+    iterator: AsyncIterator<T, E>,
+    callback: ErrorCallback<E>,
+): void;
 export function each<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>): Promise<void>;
 export const eachSeries: typeof each;
-export function eachLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>, callback: ErrorCallback<E>): void;
-export function eachLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>): Promise<void>;
+export function eachLimit<T, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncIterator<T, E>,
+    callback: ErrorCallback<E>,
+): void;
+export function eachLimit<T, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncIterator<T, E>,
+): Promise<void>;
 export const forEach: typeof each;
 export const forEachSeries: typeof each;
 export const forEachLimit: typeof eachLimit;
-export function forEachOf<T, E = Error>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>, callback: ErrorCallback<E>): void;
-export function forEachOf<T, E = Error>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>): Promise<void>;
+export function forEachOf<T, E = Error>(
+    obj: IterableCollection<T>,
+    iterator: AsyncForEachOfIterator<T, E>,
+    callback: ErrorCallback<E>,
+): void;
+export function forEachOf<T, E = Error>(
+    obj: IterableCollection<T>,
+    iterator: AsyncForEachOfIterator<T, E>,
+): Promise<void>;
 export const forEachOfSeries: typeof forEachOf;
-export function forEachOfLimit<T, E = Error>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback: ErrorCallback<E>): void;
-export function forEachOfLimit<T, E = Error>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>): Promise<void>;
+export function forEachOfLimit<T, E = Error>(
+    obj: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncForEachOfIterator<T, E>,
+    callback: ErrorCallback<E>,
+): void;
+export function forEachOfLimit<T, E = Error>(
+    obj: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncForEachOfIterator<T, E>,
+): Promise<void>;
 export const eachOf: typeof forEachOf;
 export const eachOfSeries: typeof forEachOf;
 export const eachOfLimit: typeof forEachOfLimit;
 export function map<T, R, E = Error>(
     arr: IterableCollection<T>,
-    iterator: (AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>),
-    callback: AsyncResultArrayCallback<R, E>
-    ): void;
+    iterator: AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>,
+    callback: AsyncResultArrayCallback<R, E>,
+): void;
 export function map<T, R, E = Error>(
     arr: IterableCollection<T>,
-    iterator: (AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>)
-    ): Promise<R[]>;
+    iterator: AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>,
+): Promise<R[]>;
 
 export const mapSeries: typeof map;
 export function mapLimit<T, R, E = Error>(
     arr: IterableCollection<T>,
-    limit: number, iterator: (AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>),
-    callback: AsyncResultArrayCallback<R, E>
-    ): void;
+    limit: number,
+    iterator: AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>,
+    callback: AsyncResultArrayCallback<R, E>,
+): void;
 export function mapLimit<T, R, E = Error>(
     arr: IterableCollection<T>,
-    limit: number, iterator: (AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>)
-    ): Promise<R[]>;
+    limit: number,
+    iterator: AsyncResultIterator<T, R, E> | AsyncResultIteratorPromise<T, R>,
+): Promise<R[]>;
 
 export function mapValuesLimit<T, R, E = Error>(
     obj: Dictionary<T>,
     limit: number,
     iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void,
-    callback: AsyncResultObjectCallback<R, E>
-    ): void;
+    callback: AsyncResultObjectCallback<R, E>,
+): void;
 export function mapValuesLimit<T, R, E = Error>(
     obj: Dictionary<T>,
     limit: number,
-    iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void
+    iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void,
 ): Promise<R>;
 
-export function mapValues<T, R, E = Error>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
+export function mapValues<T, R, E = Error>(
+    obj: Dictionary<T>,
+    iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void,
+    callback: AsyncResultObjectCallback<R, E>,
+): void;
 export function mapValues<T, R, E = Error, C = unknown>(
     obj: Dictionary<T>,
-    // tslint:disable-next-line:void-return
-    iteratee: (value: T, key: string, callback: C extends undefined ? never : AsyncResultCallback<R, E>) => C extends undefined ? Promise<R> : void
+    iteratee: (
+        value: T,
+        key: string,
+        callback: C extends undefined ? never : AsyncResultCallback<R, E>,
+        // tslint:disable-next-line:void-return
+    ) => C extends undefined ? Promise<R> : void,
 ): Promise<Dictionary<R>>;
 export const mapValuesSeries: typeof mapValues;
-export function filter<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function filter<T, E = Error>(
+    arr: IterableCollection<T>,
+    iterator: AsyncBooleanIterator<T, E>,
+    callback: AsyncResultArrayCallback<T, E>,
+): void;
 export function filter<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<T[]>;
 export const filterSeries: typeof filter;
-export function filterLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback: AsyncResultArrayCallback<T, E>): void;
-export function filterLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>): Promise<T[]>;
+export function filterLimit<T, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncBooleanIterator<T, E>,
+    callback: AsyncResultArrayCallback<T, E>,
+): void;
+export function filterLimit<T, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncBooleanIterator<T, E>,
+): Promise<T[]>;
 export const select: typeof filter;
 export const selectSeries: typeof filter;
 export const selectLimit: typeof filterLimit;
 export const reject: typeof filter;
 export const rejectSeries: typeof filter;
 export const rejectLimit: typeof filterLimit;
-export function reduce<T, R, E = Error>(arr: T[] | IterableIterator<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>, callback: AsyncResultCallback<R, E>): void;
-export function reduce<T, R, E = Error>(arr: T[] | IterableIterator<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>): Promise<R>;
+export function reduce<T, R, E = Error>(
+    arr: T[] | IterableIterator<T>,
+    memo: R,
+    iterator: AsyncMemoIterator<T, R, E>,
+    callback: AsyncResultCallback<R, E>,
+): void;
+export function reduce<T, R, E = Error>(
+    arr: T[] | IterableIterator<T>,
+    memo: R,
+    iterator: AsyncMemoIterator<T, R, E>,
+): Promise<R>;
 export const inject: typeof reduce;
 export const foldl: typeof reduce;
 export const reduceRight: typeof reduce;
 export const foldr: typeof reduce;
-export function detect<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback: AsyncResultCallback<T, E>): void;
+export function detect<T, E = Error>(
+    arr: IterableCollection<T>,
+    iterator: AsyncBooleanIterator<T, E>,
+    callback: AsyncResultCallback<T, E>,
+): void;
 export function detect<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<T>;
 export const detectSeries: typeof detect;
-export function detectLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback: AsyncResultCallback<T, E>): void;
-export function detectLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>): Promise<T>;
+export function detectLimit<T, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncBooleanIterator<T, E>,
+    callback: AsyncResultCallback<T, E>,
+): void;
+export function detectLimit<T, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncBooleanIterator<T, E>,
+): Promise<T>;
 export const find: typeof detect;
 export const findSeries: typeof detect;
 export const findLimit: typeof detectLimit;
-export function sortBy<T, V, E = Error>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, V, E>, callback: AsyncResultArrayCallback<T, E>): void;
-export function sortBy<T, V, E = Error>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, V, E>): Promise<T[]>;
-export function some<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback: AsyncBooleanResultCallback<E>): void;
+export function sortBy<T, V, E = Error>(
+    arr: T[] | IterableIterator<T>,
+    iterator: AsyncResultIterator<T, V, E>,
+    callback: AsyncResultArrayCallback<T, E>,
+): void;
+export function sortBy<T, V, E = Error>(
+    arr: T[] | IterableIterator<T>,
+    iterator: AsyncResultIterator<T, V, E>,
+): Promise<T[]>;
+export function some<T, E = Error>(
+    arr: IterableCollection<T>,
+    iterator: AsyncBooleanIterator<T, E>,
+    callback: AsyncBooleanResultCallback<E>,
+): void;
 export function some<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<boolean>;
 export const someSeries: typeof some;
-export function someLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function someLimit<T, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncBooleanIterator<T, E>,
+    callback?: AsyncBooleanResultCallback<E>,
+): void;
 export const any: typeof some;
 export const anySeries: typeof someSeries;
 export const anyLimit: typeof someLimit;
-export function every<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback: AsyncBooleanResultCallback<E>): void;
+export function every<T, E = Error>(
+    arr: IterableCollection<T>,
+    iterator: AsyncBooleanIterator<T, E>,
+    callback: AsyncBooleanResultCallback<E>,
+): void;
 export function every<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<boolean>;
 export const everySeries: typeof every;
-export function everyLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback: AsyncBooleanResultCallback<E>): void;
-export function everyLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>): Promise<boolean>;
+export function everyLimit<T, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncBooleanIterator<T, E>,
+    callback: AsyncBooleanResultCallback<E>,
+): void;
+export function everyLimit<T, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncBooleanIterator<T, E>,
+): Promise<boolean>;
 export const all: typeof every;
 export const allSeries: typeof every;
 export const allLimit: typeof everyLimit;
 
-export function concat<T, R, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R[], E>, callback: AsyncResultArrayCallback<R, E>): void;
-export function concat<T, R, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R[], E>): Promise<R[]>;
-export function concatLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>, callback: AsyncResultArrayCallback<R, E>): void;
-export function concatLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>): Promise<R[]>;
+export function concat<T, R, E = Error>(
+    arr: IterableCollection<T>,
+    iterator: AsyncResultIterator<T, R[], E>,
+    callback: AsyncResultArrayCallback<R, E>,
+): void;
+export function concat<T, R, E = Error>(
+    arr: IterableCollection<T>,
+    iterator: AsyncResultIterator<T, R[], E>,
+): Promise<R[]>;
+export function concatLimit<T, R, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncResultIterator<T, R[], E>,
+    callback: AsyncResultArrayCallback<R, E>,
+): void;
+export function concatLimit<T, R, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncResultIterator<T, R[], E>,
+): Promise<R[]>;
 export const concatSeries: typeof concat;
 export const flatMap: typeof concat;
 export const flatMapLimit: typeof concatLimit;
 export const flatMapSeries: typeof concatSeries;
 
-export function groupBy<T, K, E = Error>(iterable: IterableCollection<T>, iterator: AsyncResultIterator<T, K, E>, callback: AsyncResultCallback<Record<string, T[]>, E>): void;
-export function groupBy<T, K, E = Error>(iterable: IterableCollection<T>, iterator: AsyncResultIterator<T, K, E>): Promise<Record<string, T[]>>;
-export function groupByLimit<T, K, E = Error>(iterable: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, K, E>, callback: AsyncResultCallback<Record<string, T[]>, E>): void;
-export function groupByLimit<T, K, E = Error>(iterable: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, K, E>): Promise<Record<string, T[]>>;
+export function groupBy<T, K, E = Error>(
+    iterable: IterableCollection<T>,
+    iterator: AsyncResultIterator<T, K, E>,
+    callback: AsyncResultCallback<Record<string, T[]>, E>,
+): void;
+export function groupBy<T, K, E = Error>(
+    iterable: IterableCollection<T>,
+    iterator: AsyncResultIterator<T, K, E>,
+): Promise<Record<string, T[]>>;
+export function groupByLimit<T, K, E = Error>(
+    iterable: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncResultIterator<T, K, E>,
+    callback: AsyncResultCallback<Record<string, T[]>, E>,
+): void;
+export function groupByLimit<T, K, E = Error>(
+    iterable: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncResultIterator<T, K, E>,
+): Promise<Record<string, T[]>>;
 export const groupBySeries: typeof groupBy;
 
 // Control Flow
 export function series<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultArrayCallback<T, E>): void;
-export function series<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback: AsyncResultObjectCallback<T, E>): void;
+export function series<T, E = Error>(
+    tasks: Dictionary<AsyncFunction<T, E>>,
+    callback: AsyncResultObjectCallback<T, E>,
+): void;
 export function series<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Promise<T[]>;
 export function series<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>): Promise<Dictionary<T>>;
-export function parallel<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultArrayCallback<T, E>): void;
-export function parallel<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback: AsyncResultObjectCallback<T, E>): void;
-export function parallel<T, R, E = Error>(tasks: Array<AsyncFunction<T, E>> | Dictionary<AsyncFunction<T, E>>): Promise<R>;
-export function parallelLimit<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback: AsyncResultArrayCallback<T, E>): void;
-export function parallelLimit<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback: AsyncResultObjectCallback<T, E>): void;
-export function parallelLimit<T, R, E = Error>(tasks: Array<AsyncFunction<T, E>> | Dictionary<AsyncFunction<T, E>>, limit: number): Promise<R>;
+export function parallel<T, E = Error>(
+    tasks: Array<AsyncFunction<T, E>>,
+    callback: AsyncResultArrayCallback<T, E>,
+): void;
+export function parallel<T, E = Error>(
+    tasks: Dictionary<AsyncFunction<T, E>>,
+    callback: AsyncResultObjectCallback<T, E>,
+): void;
+export function parallel<T, R, E = Error>(
+    tasks: Array<AsyncFunction<T, E>> | Dictionary<AsyncFunction<T, E>>,
+): Promise<R>;
+export function parallelLimit<T, E = Error>(
+    tasks: Array<AsyncFunction<T, E>>,
+    limit: number,
+    callback: AsyncResultArrayCallback<T, E>,
+): void;
+export function parallelLimit<T, E = Error>(
+    tasks: Dictionary<AsyncFunction<T, E>>,
+    limit: number,
+    callback: AsyncResultObjectCallback<T, E>,
+): void;
+export function parallelLimit<T, R, E = Error>(
+    tasks: Array<AsyncFunction<T, E>> | Dictionary<AsyncFunction<T, E>>,
+    limit: number,
+): Promise<R>;
 
 export function whilst<T, E = Error>(
     test: (cb: AsyncBooleanResultCallback) => void,
     fn: AsyncFunctionEx<T, E>,
-    callback: AsyncResultRestCallback<T, E>
+    callback: AsyncResultRestCallback<T, E>,
 ): void;
 export function whilst<T, R, E = Error>(
     test: (cb: AsyncBooleanResultCallback) => void,
-    fn: AsyncFunctionEx<T, E>
+    fn: AsyncFunctionEx<T, E>,
 ): Promise<R>;
 export function doWhilst<T, E = Error>(
     fn: AsyncFunctionEx<T, E>,
     test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void,
-    callback: AsyncResultRestCallback<T, E>
+    callback: AsyncResultRestCallback<T, E>,
 ): void;
 export function doWhilst<T, R, E = Error>(
     fn: AsyncFunctionEx<T, E>,
-    test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void
+    test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void,
 ): Promise<R>;
 export function until<T, E = Error>(
     test: (cb: AsyncBooleanResultCallback) => void,
     fn: AsyncFunctionEx<T, E>,
-    callback: AsyncResultRestCallback<T, E>
+    callback: AsyncResultRestCallback<T, E>,
 ): void;
 export function until<T, R, E = Error>(
     test: (cb: AsyncBooleanResultCallback) => void,
-    fn: AsyncFunctionEx<T, E>
+    fn: AsyncFunctionEx<T, E>,
 ): Promise<R>;
 export function doUntil<T, E = Error>(
     fn: AsyncFunctionEx<T, E>,
     test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void,
-    callback: AsyncResultRestCallback<T, E>
+    callback: AsyncResultRestCallback<T, E>,
 ): void;
 export function doUntil<T, R, E = Error>(
     fn: AsyncFunctionEx<T, E>,
-    test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void
+    test: (/* ...results: T[], */ cb: AsyncBooleanResultCallback) => void,
 ): Promise<R>;
 
-export function during<E = Error>(test: (testCallback: AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function doDuring<E = Error>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
+export function during<E = Error>(
+    test: (testCallback: AsyncBooleanResultCallback<E>) => void,
+    fn: AsyncVoidFunction<E>,
+    callback: ErrorCallback<E>,
+): void;
+export function doDuring<E = Error>(
+    fn: AsyncVoidFunction<E>,
+    test: (testCallback: AsyncBooleanResultCallback<E>) => void,
+    callback: ErrorCallback<E>,
+): void;
 export function forever<E = Error>(next: (next: ErrorCallback<E>) => void, errBack: ErrorCallback<E>): void;
 export function waterfall<T>(tasks: Function[]): Promise<T>;
 export function waterfall<T, E = Error>(tasks: Function[], callback: AsyncResultCallback<T, E>): void;
 export function compose(...fns: Function[]): Function;
 export function seq(...fns: Function[]): Function;
-export function applyEach(fns: Function[], ...argsAndCallback: any[]): void;           // applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
-export function applyEachSeries(fns: Function[], ...argsAndCallback: any[]): void;     // applyEachSeries(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
+export function applyEach(fns: Function[], ...argsAndCallback: any[]): void; // applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
+export function applyEachSeries(fns: Function[], ...argsAndCallback: any[]): void; // applyEachSeries(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
 export function queue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency?: number): QueueObject<T>;
 export function queue<T, R, E = Error>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): QueueObject<T>;
 export function priorityQueue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncPriorityQueue<T>;
@@ -411,9 +615,19 @@ export function cargoQueue<T, E = Error>(
     concurrency?: number,
     payload?: number,
 ): QueueObject<T>;
-export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, concurrency?: number): Promise<R>;
-export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, concurrency: number, callback: AsyncResultCallback<R, E>): void;
-export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, callback: AsyncResultCallback<R, E>): void;
+export function auto<R extends Dictionary<any>, E = Error>(
+    tasks: AsyncAutoTasks<R, E>,
+    concurrency?: number,
+): Promise<R>;
+export function auto<R extends Dictionary<any>, E = Error>(
+    tasks: AsyncAutoTasks<R, E>,
+    concurrency: number,
+    callback: AsyncResultCallback<R, E>,
+): void;
+export function auto<R extends Dictionary<any>, E = Error>(
+    tasks: AsyncAutoTasks<R, E>,
+    callback: AsyncResultCallback<R, E>,
+): void;
 export function autoInject<E = Error>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
 
 export interface RetryOptions<E> {
@@ -447,53 +661,80 @@ export function apply<E = Error>(fn: Function, ...args: any[]): AsyncFunction<an
 export function nextTick(callback: Function, ...args: any[]): void;
 export const setImmediate: typeof nextTick;
 
-export function reflect<T, E = Error>(fn: AsyncFunction<T, E>): (callback: (err: null, result: {error?: E | undefined, value?: T | undefined}) => void) => void;
-export function reflectAll<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Array<(callback: (err: null, result: {error?: E | undefined, value?: T | undefined}) => void) => void>;
+export function reflect<T, E = Error>(
+    fn: AsyncFunction<T, E>,
+): (callback: (err: null, result: { error?: E | undefined; value?: T | undefined }) => void) => void;
+export function reflectAll<T, E = Error>(
+    tasks: Array<AsyncFunction<T, E>>,
+): Array<(callback: (err: null, result: { error?: E | undefined; value?: T | undefined }) => void) => void>;
 
 export function timeout<T, E = Error>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E>;
-export function timeout<T, R, E = Error>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E>;
+export function timeout<T, R, E = Error>(
+    fn: AsyncResultIterator<T, R, E>,
+    milliseconds: number,
+    info?: any,
+): AsyncResultIterator<T, R, E>;
 
-export function times<T, E = Error>(n: number, iterator: (AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>), callback: AsyncResultArrayCallback<T, E>): void;
-export function times<T, E = Error>(n: number, iterator: (AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>)): Promise<T>;
+export function times<T, E = Error>(
+    n: number,
+    iterator: AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>,
+    callback: AsyncResultArrayCallback<T, E>,
+): void;
+export function times<T, E = Error>(
+    n: number,
+    iterator: AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>,
+): Promise<T>;
 
 export const timesSeries: typeof times;
 export function timesLimit<T, E = Error>(
     n: number,
     limit: number,
-    iterator: (AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>),
-    callback: AsyncResultArrayCallback<T, E>
-    ): void;
+    iterator: AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>,
+    callback: AsyncResultArrayCallback<T, E>,
+): void;
 export function timesLimit<T, E = Error>(
     n: number,
     limit: number,
-    iterator: (AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>)
-    ): Promise<T>;
+    iterator: AsyncResultIterator<number, T, E> | AsyncResultIteratorPromise<number, T>,
+): Promise<T>;
 
-export function transform<T, R, E = Error>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
-export function transform<T, R, E = Error>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
+export function transform<T, R, E = Error>(
+    arr: T[],
+    iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void,
+    callback?: AsyncResultArrayCallback<T, E>,
+): void;
+export function transform<T, R, E = Error>(
+    arr: T[],
+    acc: R[],
+    iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void,
+    callback?: AsyncResultArrayCallback<T, E>,
+): void;
 
 export function transform<T, R, E = Error>(
-    arr: {[key: string]: T},
-    iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void,
-    callback?: AsyncResultObjectCallback<T, E>
-    ): void;
+    arr: { [key: string]: T },
+    iteratee: (acc: { [key: string]: R }, item: T, key: string, callback: (error?: E) => void) => void,
+    callback?: AsyncResultObjectCallback<T, E>,
+): void;
 
 export function transform<T, R, E = Error>(
-    arr: {[key: string]: T},
-    acc: {[key: string]: R},
-    iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void,
-    callback?: AsyncResultObjectCallback<T, E>
-    ): void;
+    arr: { [key: string]: T },
+    acc: { [key: string]: R },
+    iteratee: (acc: { [key: string]: R }, item: T, key: string, callback: (error?: E) => void) => void,
+    callback?: AsyncResultObjectCallback<T, E>,
+): void;
 
 export function race<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultCallback<T, E>): void;
 
-export function tryEach<T, E = Error>(tasks: IterableCollection<AsyncFunction<T>>, callback: AsyncResultCallback<T, E>): void;
+export function tryEach<T, E = Error>(
+    tasks: IterableCollection<AsyncFunction<T>>,
+    callback: AsyncResultCallback<T, E>,
+): void;
 export function tryEach<T>(tasks: IterableCollection<AsyncFunction<T>>): Promise<T>;
 
 // Utils
 export function memoize(fn: Function, hasher?: Function): Function;
 export function unmemoize(fn: Function): Function;
-export function ensureAsync(fn: (... argsAndCallback: any[]) => void): Function;
+export function ensureAsync(fn: (...argsAndCallback: any[]) => void): Function;
 export function constant(...values: any[]): AsyncFunction<any>;
 export function asyncify(fn: Function): (...args: any[]) => any;
 export function wrapSync(fn: Function): Function;

async/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/async",
-    "version": "3.2.19",
+    "version": "3.2.21",
     "description": "TypeScript definitions for Async",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/async",
     "license": "MIT",
@@ -15,11 +15,6 @@
             "url": "https://github.com/kern0",
             "githubUsername": "kern0"
         },
-        {
-            "name": "Joe Herman",
-            "url": "https://github.com/Penryn",
-            "githubUsername": "Penryn"
-        },
         {
             "name": "Angus Fenying",
             "url": "https://github.com/fenying",
@@ -60,6 +55,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "a7767c80777d9eb61901e768e308c054fa26cf1d39a98b3870397d6f75d24d66",
-    "typeScriptVersion": "4.3"
+    "typesPublisherContentHash": "1fcaace91e1eb18e5067df2372847ac266bc288bee9edf10e887ddf6d3b294d0",
+    "typeScriptVersion": "4.5"
 }