//#region src/utils/results.d.ts
type Result<T, E = unknown> = {
  status: "ok";
  data: T;
} | {
  status: "error";
  error: E;
};
type AsyncResult<T, E = unknown, P = void> = Result<T, E> | ({
  status: "pending";
} & {
  progress: P;
});
declare const Result: {
  fromThrowing: typeof fromThrowing;
  fromThrowingAsync: typeof fromThrowingAsync;
  fromPromise: typeof promiseToResult;
  ok<T>(data: T): Result<T, never> & {
    status: "ok";
  };
  error<E>(error: E): Result<never, E> & {
    status: "error";
  };
  map: typeof mapResult;
  or: <T, E, U>(result: Result<T, E>, fallback: U) => T | U;
  orThrow: <T, E>(result: Result<T, E>) => T;
  orThrowAsync: <T, E>(result: Promise<Result<T, E>>) => Promise<T>;
  retry: typeof retry;
};
declare const AsyncResult: {
  fromThrowing: typeof fromThrowing;
  fromPromise: typeof promiseToResult;
  ok: <T>(data: T) => Result<T, never> & {
    status: "ok";
  };
  error: <E>(error: E) => Result<never, E> & {
    status: "error";
  };
  pending: typeof pending;
  map: typeof mapResult;
  or: <T, E, P, U>(result: AsyncResult<T, E, P>, fallback: U) => T | U;
  orThrow: <T, E, P>(result: AsyncResult<T, E, P>) => T;
  retry: typeof retry;
};
declare function pending(): AsyncResult<never, never, void> & {
  status: "pending";
};
declare function pending<P>(progress: P): AsyncResult<never, never, P> & {
  status: "pending";
};
declare function promiseToResult<T>(promise: Promise<T>): Promise<Result<T>>;
declare function fromThrowing<T>(fn: () => T): Result<T, unknown>;
declare function fromThrowingAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>>;
declare function mapResult<T, U, E = unknown, P = unknown>(result: Result<T, E>, fn: (data: T) => U): Result<U, E>;
declare function mapResult<T, U, E = unknown, P = unknown>(result: AsyncResult<T, E, P>, fn: (data: T) => U): AsyncResult<U, E, P>;
declare class RetryError<E = unknown> extends AggregateError {
  readonly errors: E[];
  constructor(errors: E[]);
  get attempts(): number;
}
declare function retry<T, E>(fn: (attemptIndex: number) => Result<T, E> | Promise<Result<T, E>>, totalAttempts: number, {
  exponentialDelayBase
}?: {
  exponentialDelayBase?: number | undefined;
}): Promise<Result<T, RetryError<E>> & {
  attempts: number;
}>;
//#endregion
export { AsyncResult, Result };
//# sourceMappingURL=results.d.ts.map