import { Result } from "t-result";

//#region src/parallelAsyncCalls.d.ts
type ValidMetadata = string | number | boolean | Record<string, unknown>;
type TupleRunAllSuccess<T> = T extends (() => Promise<Result<infer V>>) ? Succeeded<V, undefined> : T extends {
  metadata: infer M;
  fn: () => Promise<Result<infer V>>;
} ? Succeeded<V, M> : never;
type TupleRunAllFailed<T> = T extends (() => Promise<Result<any>>) ? {
  metadata: undefined;
  error: Error;
} : T extends {
  metadata: infer M extends ValidMetadata;
} ? {
  metadata: M;
  error: Error;
} : never;
type TupleRunAllSettled<T> = T extends (() => Promise<Result<infer V>>) ? Succeeded<V, undefined> | Failed<undefined> : T extends {
  metadata: infer M;
  fn: () => Promise<Result<infer V>>;
} ? Succeeded<V, M> | Failed<M> : never;
type RunProps = {
  delayStart?: (index: number) => number;
};
type Failed<M$1> = {
  metadata: M$1;
  error: Error;
};
type Succeeded<R, M$1> = {
  value: R;
  metadata: M$1;
};
declare class ParallelAsyncResultCalls<M$1 extends ValidMetadata | undefined = undefined, R = unknown> {
  private pendingCalls;
  alreadyRun: boolean;
  constructor();
  add(call: M$1 extends undefined ? () => Promise<Result<R>> : {
    metadata: M$1;
    fn: () => Promise<Result<R>>;
  }): this;
  /**
   * Adds calls return tuples with inferred results
   *
   * @param calls
   */
  addTuple<T extends (M$1 extends undefined ? () => Promise<Result<R>> : {
    metadata: M$1;
    fn: () => Promise<Result<R>>;
  })[]>(...calls: T): {
    runAllSettled: (props?: RunProps) => Promise<{
      results: { [I in keyof T]: TupleRunAllSettled<T[I]> };
      allFailed: boolean;
    }>;
    runAll: (props?: RunProps) => Promise<Result<{ [I in keyof T]: TupleRunAllSuccess<T[I]> }, TupleRunAllFailed<T[number]>>>;
  };
  runAllSettled({
    delayStart
  }?: RunProps): Promise<{
    failed: Failed<M$1>[];
    succeeded: Succeeded<R, M$1>[];
    allFailed: boolean;
    results: (Failed<M$1> | Succeeded<R, M$1>)[];
  }>;
  runAll({
    delayStart
  }?: {
    delayStart?: (index: number) => number;
  }): Promise<Result<Succeeded<R, M$1>[], {
    metadata: M$1;
    error: Error;
  }>>;
}
/**
 * Executes multiple asynchronous calls in parallel and collects the results in
 * a easier to use format.
 *
 * @deprecated Use concurrentAsyncCalls instead.
 * @template R - The type of the result value.
 * @template M - The type of the call metadata.
 */
declare function parallelAsyncCalls<M$1 extends ValidMetadata | undefined = undefined, R = unknown>(): ParallelAsyncResultCalls<M$1, R>;
//#endregion
export { parallelAsyncCalls };