import { type ResultBaseError } from './baseResultError';
import { type ResultPromise, type Result, type ReturnedResultPromise } from './result';
export type AsyncResultPromise<T, E> = Promise<AsyncResult<T, E>>;
/**
 * Helper class containing promise of a Result. For more ergonomic usage of Results with async code
 */
export declare class AsyncResult<Val, Err> {
    /**
     * @param promise
     * @description returns AsyncResult containing the promise.
     * @example
     * const resPromise = AsyncResult.fromPromise(Promise.resolve(1));
     * // Type of resPromise is AsyncResult<number, unknown>
     */
    static fromPromise<Val>(promise: Promise<Val>): AsyncResult<Val, ResultBaseError>;
    /**
     * @param result
     * @description returns AsyncResult containing promise of provided result
     * @example
     * const resPromise = AsyncResult.fromResult(Ok(5));
     * // Type of resPromise is AsyncResult<number, never>
     */
    static fromResult<Val, Err>(result: Result<Val, Err>): AsyncResult<Val, Err>;
    /**
     * @param resultPromise
     * @description AsyncResult.fromResultPromise(resultPromise) returns AsyncResult containing provided resultPromise
     * @example
     * const resPromise = AsyncResult.fromResult(Promise.resolve(Ok(5)));
     * // Type of resPromise is AsyncResult<number, never>
     */
    static fromResultPromise<Val, Err>(resultPromise: ResultPromise<Val, Err>): AsyncResult<Val, Err>;
    /**
     * @description Contained promise of Result
     * @example
     * const resPromise = AsyncResult.fromPromise(Promise.resolve(1), () => 'string');
     * const awaited  = await resPromise.promise;
     * // Type of awaited is Result<number, string>
     */
    readonly promise: Promise<Result<Val, Err>>;
    constructor(promise: Promise<Result<Val, Err>>);
    /**
     * @description returns promise of result value if it's not an error, otherwise throws an exception
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * console.log(await res.unwrap()); // 5
     *
     * res = AsyncResult.fromResult(Err('err'));
     * console.log(await res.unwrap()); // Exception: Tried to unwrap an Error result
     */
    unwrap(): Promise<Val>;
    /**
     * @description returns error value if it exists, otherwise throws an exception
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * console.log(await res.unwrapErr()); // Exception: Tried to unwrap Ok result's error
     *
     * res = AsyncResult.fromResult(Err('error msg'));
     * console.log(await res.unwrapErr()); // 'error msg'
     */
    unwrapErr(): Promise<Err>;
    /**
     * @param altVal
     * @description result.unwrapOr(altVal) will return altVal in case of error
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * console.log(await res.unwrapOr(0)); // 5
     *
     * res = AsyncResult.fromResult(Err('error msg'));
     * console.log(await res.unwrapOr(0)); // 0
     */
    unwrapOr(altVal: Val): Promise<Val>;
    /**
     * @param altValFactory
     * @description result.unwrapOrElse(altValFactory) will return return value of altValFactory in case of error
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * console.log(await res.unwrapOrElse(async () => 0)); // 5
     *
     * res = AsyncResult.fromResult(Err('error msg'));
     * console.log(await res.unwrapOrElse(async () => 0)); // 0
     */
    unwrapOrElse(altValFactory: (err: Err) => AsyncMapped<Val>): Promise<Val>;
    /**
     * @param msg
     * @description result.expect(message) unwrap result or throw new Error with message in case of error
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * console.log(await res.expect('provided message')); // 5
     *
     * res = AsyncResult.fromResult(Err('error msg'));
     * console.log(await res.expect('provided message')); // Exception: provided message
     */
    expect(msg: string): Promise<Val>;
    /**
     * @param msg
     * @description result.expectErr(message) unwrap error or throw new Error with message in case of Ok
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * console.log(await res.expectErr('provided message')); // Exception: provided message
     *
     * res = AsyncResult.fromResult(Err('error msg'));
     * console.log(await res.expectErr('provided message')); // 'error msg'
     */
    expectErr(msg: string): Promise<Err>;
    /**
     * @description result.isOk() returns true if Result is Ok or false if result is Err
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * console.log(await res.isOk()); // true
     *
     * res = AsyncResult.fromResult(Err('error msg'));
     * console.log(await res.isOk()); // false
     */
    isOk(): Promise<boolean>;
    /**
     * @description result.isErr() returns false if Result is Ok or true if result is Err
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * console.log(await res.isErr()); // false
     *
     * res = AsyncResult.fromResult(Err('error msg'));
     * console.log(await res.isErr()); // true
     */
    isErr(): Promise<boolean>;
    /**
     * @description result.ok() returns value of Result if it is Ok, or undefined if it is Err
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * console.log(await res.ok()); // 5
     *
     * res = AsyncResult.fromResult(Err('error msg'));
     * console.log(await res.ok()); // undefined
     */
    ok(): Promise<Val | undefined>;
    /**
     * @description result.err() returns undefined if Result is Ok, or contained error if Result is Err
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * console.log(await res.err()); // undefined
     *
     * res = AsyncResult.fromResult(Err('error msg'));
     * console.log(await res.err()); // 'error msg'
     */
    err(): Promise<Err | undefined>;
    /**
     * @param inspector
     * @description result.inspect() will run provided inspector if Result is Ok
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * await res.inspect((val) => console.log(`logged ${val}`)).promise; // logged 5
     *
     * res = AsyncResult.fromResult(Err('error msg'));
     * await res.inspect((val) => console.log(`logged ${val}`)).promise; // <nothing>
     */
    inspect(inspector: (val: Val) => any): AsyncResult<Val, Err>;
    /**
     * @param inspector
     * @description result.inspectErr() will run provided inspector if Result is Err
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * await res.inspectErr((val) => console.log(`logged ${val}`)).promise; // <nothing>
     *
     * res = AsyncResult.fromResult(Err('error msg'));
     * await res.inspectErr((val) => console.log(`logged ${val}`)).promise; // logged error msg
     */
    inspectErr(inspector: (err: Err) => any): AsyncResult<Val, Err>;
    /**
     * @param mapper
     * @description result.map(mapper) will run provided mapper with Result value if Result is Ok
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * console.log(await res.map((val) => val + 1).unwrap()); // 6
     */
    map<NewVal>(mapper: (val: Val) => AsyncMapped<NewVal>): AsyncResult<NewVal, Err>;
    /**
     * @param mapper
     * @param fallback
     * @description result.mapOrElse(mapper, fallback) will run provided mapper with Result value if Result is Ok
     *              ir run provided fallback with Result error if Result is Err
     * @example
     * let res = AsyncResult.fromResult(Ok(5));
     * console.log(await res.map((val) => val + 1, err => err + ' suffix').unwrap()); // 6
     *
     * res = AsyncResult.fromResult(Err('error msg'));
     * console.log(await res.map((val) => val + 1, err => err + ' suffix').unwrapErr()); // error msg suffix
     */
    mapOrElse<NewVal>(mapper: (val: Val) => AsyncMapped<NewVal>, fallback: (err: Err) => AsyncMapped<NewVal>): AsyncResult<NewVal, Err>;
    /**
     * @param mapper
     * @description result.mapErr(mapper) will run provided mapper with Result error if Result is Err
     * @example
     * let res = AsyncResult.fromResult(Err('error msg'));
     * console.log(await res.mapErr(err => err + ' suffix').unwrapErr()); // error msg suffix
     */
    mapErr<NewErr>(mapper: (err: Err) => AsyncMapped<NewErr>): AsyncResult<Val, NewErr>;
    private thenInternal;
}
type AsyncMapped<T> = T | Promise<T>;
/**
 * @description Creates function returning AsyncResult<T, E> from provided FN returning Promise<T> and
 *              optional error mapper returning E or Promise<E>.
 *              If FN throws exception, it is caught and passed to the error mapper.
 * @example
 * const rawFn = async (a: number) => {
 *     if (a < 0) {
 *         throw new Error('not today')
 *     }
 *     return a;
 * };
 *
 * const fn = asyncResultify(
 *     rawFn,
 *     async err => err.message
 * ); // (a: number) => AsyncResult<number, string>
 *
 * const res = fn(-2); // AsyncResult<number, string>
 * await res.err() // 'not today'
 */
export declare function asyncResultify<TRes, TParams extends any[], E = ResultBaseError>(fn: (...params: TParams) => Promise<TRes>, mapErr?: (err: ResultBaseError) => AsyncMapped<E>): (...params: TParams) => AsyncResult<TRes, E>;
/**
 * @param fn
 * @description Wraps fn changing its return type from ResultPromise<T, E> to AsyncResult<T, E>
 * @example
 * const resultPromiseFn = async (a: number): ResultPromise<number, string> => {
 *     if (a < 0) {
 *         return Err('err');
 *     }
 *
 *     return Ok(a);;
 * };
 *
 * const resUnwrapped = (await resultPromiseFn(2)).unwrap();
 *
 * const fn = createAsyncResultFn(resultPromiseFn); // (a: number) => AsyncResult<number, string>
 * const resWrapped = await fn(2).unwrap(); // Same result, with more convenient async handling
 */
export declare function createAsyncResult<TRes, TParams extends any[], E>(fn: (...params: TParams) => ReturnedResultPromise<TRes, E>): (...params: TParams) => AsyncResult<TRes, E>;
/**
 * @param promise
 * @description Converts promise resolve / reject to Ok() or Err()
 * @example
 * const promise = Promise.reject();
 * const result = toAsyncResult(promise);
 */
export declare function toAsyncResult<Val>(promise: Promise<Val>): AsyncResult<Val, ResultBaseError>;
export {};
//# sourceMappingURL=asyncResult.d.ts.map