import { Result, ResultValidErrors } from "t-result";

//#region src/concurrentCalls.d.ts
declare class ConcurrentCallsAggregateError extends AggregateError {
  errors: ResultValidErrors[];
  total: number;
  failed: number;
  constructor(errors: ResultValidErrors[], total: number, failed: number);
}
declare class ConcurrentCallsWithMetadataAggregateError<M extends ValidMetadata> extends AggregateError {
  errors: ResultValidErrors[];
  errorsWithMetadata: {
    error: ResultValidErrors;
    metadata: M;
  }[];
  total: number;
  failed: number;
  constructor(errors: {
    error: ResultValidErrors;
    metadata: M;
  }[], total: number, failed: number);
}
type ValidMetadata = string | number | boolean | Record<string, unknown>;
type RunProps = {
  delayStart?: (index: number) => number;
};
type SucceededCall<R, M> = {
  value: R;
  metadata: M;
};
type FailedCall<M, E extends ResultValidErrors = Error> = {
  metadata: M;
  error: E;
};
type Action<R, E extends ResultValidErrors> = () => Promise<Result<R, E>>;
type SettledResultWithMetadata<R, M, E extends ResultValidErrors = Error> = {
  ok: true;
  value: R;
  metadata: M;
  error: false;
} | {
  ok: false;
  error: E;
  metadata: M;
};
declare class ConcurrentCalls<R = unknown, E extends ResultValidErrors = Error> {
  #private;
  allowResultify: boolean;
  constructor(allowResultify: boolean);
  add(...calls: Action<R, E>[]): this;
  resultifyAdd(...calls: ((() => R) | (() => Promise<R>))[]): this;
  runAll({
    delayStart
  }?: RunProps): Promise<Result<R[], E>>;
  runAllSettled({
    delayStart
  }?: RunProps): Promise<{
    allFailed: boolean;
    failures: E[];
    succeeded: R[];
    total: number;
    aggregatedError: ConcurrentCallsAggregateError | null;
  }>;
}
/**
 * Executes multiple asynchronous calls concurrently and collects the results in
 * a easier to use format.
 *
 * @template R - The type of the result value.
 */
declare function concurrentCalls<R = unknown>(): ConcurrentCalls<R, Error>;
declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends ResultValidErrors = Error> {
  #private;
  allowResultify: boolean;
  constructor(allowResultify: boolean);
  add(...calls: {
    fn: Action<R, E>;
    metadata: M;
  }[]): this;
  resultifyAdd(...items: {
    fn: (() => R) | (() => Promise<R>);
    metadata: M;
  }[]): this;
  runAll({
    delayStart
  }?: RunProps): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;
  runAllSettled({
    delayStart
  }?: RunProps): Promise<{
    allFailed: boolean;
    /** @deprecated Use failures property instead */
    failed: FailedCall<M, E>[];
    failures: FailedCall<M, E>[];
    succeeded: SucceededCall<R, M>[];
    total: number;
    results: SettledResultWithMetadata<R, M, E>[];
    aggregatedError: ConcurrentCallsWithMetadataAggregateError<M> | null;
  }>;
}
/**
 * Executes multiple asynchronous calls concurrently with metadata for each call
 * and collects the results in a easier to use format.
 *
 * @template M - The type of the call metadata.
 * @template R - The type of the result value.
 */
declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknown>(): ConcurrentCallsWithMetadata<M, R, Error>;
type ValueFromResult<R> = R extends Result<infer T, any> ? T : never;
type ErrorFromResult<R> = R extends Result<any, infer E> ? E : never;
/**
 * Executes multiple asynchronous result calls concurrently and collects the
 * results in a easier to use format.
 *
 * @template R - The type of the result function that will be called.
 */
declare function concurrentResultCalls<ResultFn extends (...args: any[]) => Promise<Result<unknown, ResultValidErrors>>>(): ConcurrentCalls<ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
/**
 * Executes multiple asynchronous result calls concurrently with metadata for
 * each call and collects the results in a easier to use format.
 *
 * @template ResultFn - The type of the result function that will be called.
 */
declare function concurrentResultsWithMetadata<M extends ValidMetadata, ResultFn extends (...args: any[]) => Promise<Result<unknown, ResultValidErrors>>>(): ConcurrentCallsWithMetadata<M, ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
//#endregion
export { ConcurrentCallsAggregateError, ConcurrentCallsWithMetadataAggregateError, concurrentCalls, concurrentCallsWithMetadata, concurrentResultCalls, concurrentResultsWithMetadata };