@types/async 3.2.24 → 3.2.26

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: Wed, 22 Nov 2023 00:24:48 GMT
+ * Last updated: Wed, 09 Sep 2026 17:32:37 GMT
  * Dependencies: none
 
 # Credits

async/index.d.ts

@@ -125,26 +125,30 @@ export interface QueueObject<T> {
      * Instead of a single task, a tasks array can be submitted.
      * The respective callback is used for every task in the list.
      */
-    push<R>(task: T | T[]): Promise<R>;
+    push<R>(task: T): Promise<R>;
+    push<R>(task: T[]): Promise<R>[] | undefined;
     push<R, E = Error>(task: T | T[], callback: AsyncResultCallback<R, E>): void;
 
     /**
      * Add a new task to the front of the queue
      */
-    unshift<R>(task: T | T[]): Promise<R>;
+    unshift<R>(task: T): Promise<R>;
+    unshift<R>(task: T[]): Promise<R>[] | undefined;
     unshift<R, E = Error>(task: T | T[], callback: AsyncResultCallback<R, E>): void;
 
     /**
      * The same as `q.push`, except this returns a promise that rejects if an error occurs.
      * The `callback` arg is ignored
      */
-    pushAsync<R>(task: T | T[]): Promise<R>;
+    pushAsync<R>(task: T): Promise<R>;
+    pushAsync<R>(task: T[]): Promise<R>[] | undefined;
 
     /**
      * The same as `q.unshift`, except this returns a promise that rejects if an error occurs.
      * The `callback` arg is ignored
      */
-    unshiftAsync<R>(task: T | T[]): Promise<R>;
+    unshiftAsync<R>(task: T): Promise<R>;
+    unshiftAsync<R>(task: T[]): Promise<R>[] | undefined;
 
     /**
      * Remove items from the queue that match a test function.
@@ -239,7 +243,8 @@ export interface QueueObject<T> {
  */
 // 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">> {
-    push<R>(task: T | T[], priority?: number): Promise<R>;
+    push<R>(task: T, priority?: number): Promise<R>;
+    push<R>(task: T[], priority?: number): undefined | Promise<R>[];
     push<R, E = Error>(task: T | T[], priority: number, callback: AsyncResultCallback<R, E>): void;
 }
 
@@ -431,8 +436,13 @@ export function someLimit<T, E = Error>(
     arr: IterableCollection<T>,
     limit: number,
     iterator: AsyncBooleanIterator<T, E>,
-    callback?: AsyncBooleanResultCallback<E>,
+    callback: AsyncBooleanResultCallback<E>,
 ): void;
+export function someLimit<T, E = Error>(
+    arr: IterableCollection<T>,
+    limit: number,
+    iterator: AsyncBooleanIterator<T, E>,
+): Promise<boolean>;
 export const any: typeof some;
 export const anySeries: typeof someSeries;
 export const anyLimit: typeof someLimit;
@@ -576,16 +586,6 @@ export function doUntil<T, R, E = Error>(
     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 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;
@@ -615,7 +615,8 @@ 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 function autoInject<E = Error>(tasks: any, callback: AsyncResultCallback<any, E>): void;
+export function autoInject(tasks: any): Promise<any>;
 
 export interface RetryOptions<E> {
     times?: number | undefined;
@@ -688,29 +689,46 @@ export function timesLimit<T, E = Error>(
 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>,
+    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,
+): Promise<Array<T | undefined>>;
 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>,
+    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,
+): Promise<Array<T | undefined>>;
 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>,
+    callback: AsyncResultObjectCallback<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,
+): Promise<Dictionary<T | undefined>>;
 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>,
+    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,
+): Promise<Dictionary<T | undefined>>;
 
 export function race<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultCallback<T, E>): void;
+export function race<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Promise<T>;
 
 export function tryEach<T, E = Error>(
     tasks: IterableCollection<AsyncFunction<T>>,

async/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/async",
-    "version": "3.2.24",
+    "version": "3.2.26",
     "description": "TypeScript definitions for async",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/async",
     "license": "MIT",
@@ -55,6 +55,7 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "d22df6dcc4644f4e587d58121a6afb56868467fd940a0c9bb41bc28d5ef07504",
-    "typeScriptVersion": "4.5"
+    "peerDependencies": {},
+    "typesPublisherContentHash": "dec5da0bd45e207433d691e0700576c19c19470ddc6dbf0ff0432ad0426fb154",
+    "typeScriptVersion": "5.6"
 }