@types/async 3.2.5 → 3.2.9

async/README.md

@@ -8,7 +8,7 @@ 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: Mon, 30 Nov 2020 19:12:26 GMT
+ * Last updated: Mon, 25 Oct 2021 23:31:43 GMT
  * Dependencies: none
  * Global values: `async`
 

async/index.d.ts

@@ -302,7 +302,8 @@ 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 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>, 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;
 
 // Control Flow
@@ -340,38 +341,44 @@ 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, 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 {
-    times?: number;
-    interval?: number | ((retryCount: number) => number);
-    errorFilter?: (error: Error) => boolean;
+export interface RetryOptions<E> {
+    times?: number | undefined;
+    interval?: number | ((retryCount: number) => number) | undefined;
+    errorFilter?: ((error: E) => boolean) | undefined;
 }
 export function retry<T, E = Error>(
-    opts?: number | RetryOptions,
-    task?: (callback: AsyncResultCallback<T, E>, results: any) => void,
-): Promise<void>;
+    task: (() => Promise<T>) | ((callback: AsyncResultCallback<T, E>) => void),
+): Promise<T>;
 export function retry<T, E = Error>(
-    opts?: number | RetryOptions,
-    task?: (callback: AsyncResultCallback<T, E>, results: any) => void,
-    callback?: AsyncResultCallback<any, E>,
+    opts: number | RetryOptions<E>,
+    task: (() => Promise<T>) | ((callback: AsyncResultCallback<T, E>) => void),
+): Promise<T>;
+export function retry<T, E = Error>(
+    task: (() => Promise<T>) | ((callback: AsyncResultCallback<T, E>) => void),
+    callback: AsyncResultCallback<T, E>,
+): void;
+export function retry<T, E = Error>(
+    opts: number | RetryOptions<E>,
+    task: (() => Promise<T>) | ((callback: AsyncResultCallback<T, E>) => void),
+    callback: AsyncResultCallback<T, E>,
 ): void;
 
 export function retryable<T, E = Error>(task: AsyncFunction<T, E>): AsyncFunction<T, E>;
 export function retryable<T, E = Error>(
-    opts:
-        | number
-        | RetryOptions & {arity?: number},
-     task: AsyncFunction<T, E>
+    opts: number | (RetryOptions<E> & { arity?: number | undefined }),
+    task: AsyncFunction<T, E>,
 ): AsyncFunction<T, E>;
 export function apply<E = Error>(fn: Function, ...args: any[]): AsyncFunction<any, E>;
 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, value?: T}) => void) => void;
-export function reflectAll<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Array<(callback: (err: null, result: {error?: E, value?: T}) => 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>;

async/package.json

@@ -1,7 +1,8 @@
 {
     "name": "@types/async",
-    "version": "3.2.5",
+    "version": "3.2.9",
     "description": "TypeScript definitions for Async",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/async",
     "license": "MIT",
     "contributors": [
         {
@@ -59,6 +60,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "5d3403505c739b80abfffa8203dc15c69212c682e9995f3b0e840012bd4e0ebe",
-    "typeScriptVersion": "3.3"
+    "typesPublisherContentHash": "3c13f25d612c145c9116a228ba5391d96870617945c1981226a0774dc0a98be9",
+    "typeScriptVersion": "3.7"
 }