type Curried$3<T, U> = (a: Result<T>) => U;
declare class WrappedResultError extends Error {
    originalError: any;
    constructor(message: string, originalError: any);
}
type UnderlyingValue<T> = {
    type: "value";
    value: T;
};
type UnderlyingError = {
    type: "error";
    error: any;
};
type Underlying<T> = UnderlyingValue<T> | UnderlyingError;
declare class Result<T> {
    private value;
    constructor(value: Underlying<T>);
    /**
     * Gets the underlying value. Note that you should check whether the value is Ok before doing this, or else a @see WrappedResultError may be thrown.
     */
    getValue(): T;
    /**
     * Gets the underlying error. Note that you should check whether the value is Error before doing this, or else a @see WrappedResultError may be thrown.
     */
    getError(): any;
    /**
     * Checks whether the value is Error.
     */
    isError(): boolean;
    /**
     * Checks whether the value is Ok.
     */
    isOk(): boolean;
    /**
     * Maps the Ok value to another value. Will only run if the value is Ok.
     */
    map<U>(mapper: (arg: T) => U): Result<U>;
    /**
     * Maps the Error value back to an OK value. Will only run if the value is Error.
     */
    mapError<U>(mapper: (arg: U) => T): Result<T>;
    /**
     * Binds the value to the result returned by the @param mapper function. Will only run if the value is Ok.
     */
    bind<U>(mapper: (arg: T) => Result<U>): Result<U>;
    /**
     * Binds the result to the one returned by the @param mapper function. Will only run if the value is Error.
     */
    bindError(mapper: (error: any) => Result<T>): Result<T>;
    /**
     * Passes the value to the given @param fn function where it can then be used for work that doesn't return a value. Will only run if the value is Ok.
     */
    iter(fn: (arg: T) => void): Result<T>;
    /**
     * Executes the given @param fn function when the result is Error.
     */
    iterError(fn: (arg: any) => void): Result<T>;
    /**
     * Returns the @param defaultValue if the Result is Error, else returns the Ok value.
     * @example
     * console.log(Result.ofValue(5).defaultValue(10)) // 5
     * console.log(Result.ofError(new Error("Test error")).defaultValue(10)) // 10
     */
    defaultValue(defaultValue: T): T;
    /**
     * Wraps the @param value in an Ok Result.
     */
    static ofValue<T>(value: T): Result<T>;
    /**
     * Wraps the @param error in an Error Result.
     */
    static ofError<T = any>(error: any): Result<T>;
    /**
     * Takes the given promise or function that returns a promise and wraps it in a try/catch. Returns Result.ofError if it throws an error.
     */
    static ofPromise<T>(promise: Promise<T> | (() => Promise<T>)): Promise<Result<T>>;
    /**
     * Takes the given function and executes it, returning Result.ofError if it throws an error.
     */
    static ofFunction<T>(computation: (() => T)): Result<T>;
    /**
     * Gets the underlying value of the Result. Note that you should check whether the value is Ok before doing this, or else a @see WrappedResultError may be thrown.
     */
    static getValue<T>(result: Result<T>): T;
    /**
     * Gets the underlying error of the Result. Note that you should check whether the value is Error before doing this, or else a @see WrappedResultError may be thrown.
     */
    static getError<T>(result: Result<T>): any;
    /**
     * Checks whether the Result is Error.
     */
    static isError<T>(result: Result<T>): boolean;
    /**
     * Checks whether the Result is Ok.
     */
    static isOk<T>(result: Result<T>): boolean;
    /**
     * Returns a curried function that will map the Ok value to another value. Will only run if the value is Ok.
     */
    static map<T, U>(mapper: (arg: T) => U): Curried$3<T, Result<U>>;
    /**
     * Returns a curried function that will map the Error value back to an OK value. Will only run if the value is Error.
     */
    static mapError<T>(mapper: (arg: any) => T): Curried$3<T, Result<T>>;
    /**
     * Returns a curried function that will bind the value to the result returned by the @param mapper function. Will only run if the value is Ok.
     */
    static bind<T, U>(mapper: (arg: T) => Result<U>): Curried$3<T, Result<U>>;
    /**
     * Returns a curried function that will bind the result to the one returned by the @param mapper function. Will only run if the value is Error.
     */
    static bindError<T>(mapper: (arg: any) => Result<T>): Curried$3<T, Result<T>>;
    /**
     * Returns a curried function that will pass the value to the given @param fn function where it can then be used for work that doesn't return a value. Will only run if the value is Ok.
     */
    static iter<T>(fn: (arg: T) => void): Curried$3<T, Result<T>>;
    /**
     * Returns a curried function that will execute the given @param fn function when the result is Error.
     */
    static iterError<T>(fn: (arg: any) => void): Curried$3<T, Result<T>>;
}

type Curried$2<T, U> = (a: Async<T>) => U;
/**
 * A monad which wraps a promise and provides convenient utility methods for working with that promise.
 */
declare class Async<T> {
    private value;
    constructor(value: Promise<T>);
    /**
     * Gets the underlying promise, which can then be awaited.
     */
    get(): Promise<T>;
    /**
     * Gets the underlying promise, wrapped in a Result. This is just a shortcut for `Result.ofPromise(Async.get())`
     */
    getResult(): Promise<Result<T>>;
    /**
     * Maps the value of the promise to another value.
     */
    map<U>(mapper: (arg: T) => U): Async<U>;
    /**
     * Binds the value of the promise to the promise returned by the @param mapper function.
     */
    bind<U>(mapper: (arg: T) => Async<U>): Async<U>;
    /**
     * Passes the value to the given @param fn function where it can then be used for work that doesn't require returning a value.
     */
    iter(fn: (arg: T) => void): Async<T>;
    /**
     * Creates an Async monad from the promise.
     */
    static ofPromise<T>(promise: Promise<T>): Async<T>;
    /**
     * Wraps a non-promise value in an Async monad.
     */
    static wrap<T>(value: T): Async<T>;
    /**
     * Gets the underlying promise, which can then be awaited.
     */
    static get<T>(a: Async<T>): Promise<T>;
    /**
     * Gets the underlying promise, wrapped in a Result. This is just a shortcut for `Result.ofPromise(Async.get())`
     */
    static getResult<T>(a: Async<T>): Promise<Result<T>>;
    /**
     * Returns a curried function that will map the value of the promise to another value.
     */
    static map<T, U>(mapper: (arg: T) => U): Curried$2<T, Async<U>>;
    /**
     * Returns a curried function that will bind the value of the promise to the promise returned by the @param mapper function.
     */
    static bind<T, U>(mapper: (arg: T) => Async<U>): Curried$2<T, Async<U>>;
    /**
     * Returns a curried function that will pass the value to the given @param fn function where it can then be used for work that doesn't require returning a value.
     */
    static iter<T>(fn: (arg: T) => void): Curried$2<T, Async<T>>;
}

type Curried$1<T, U> = (a: AsyncResult<T>) => U;
declare class AsyncResult<T> {
    private value;
    constructor(value: Promise<Result<T>>);
    /**
     * Gets the underlying promise, which can then be awaited to return a @see Result
     */
    get(): Promise<Result<T>>;
    /**
     * Maps the OK value to another value. Will only run if the value is OK.
     */
    map<U>(fn: (arg: T) => U): AsyncResult<U>;
    /**
     * Maps the Error value back to an OK value. Will only run if the value is Error.
     */
    mapError(fn: (arg: any) => T): AsyncResult<T>;
    /**
     * Binds the OK value to the AsyncResult returned by the @param fn function. Will only run if the value is OK.
     */
    bind<U>(fn: (arg: T) => AsyncResult<U>): AsyncResult<U>;
    /**
     * Binds the Error value to the AsyncReuslt returned by the @param fn function. Will only run if the value is Error.
     */
    bindError(fn: (arg: any) => AsyncResult<T>): AsyncResult<T>;
    /**
     * Passes the OK value to the given @param fn function. Will only run if the value is OK.
     */
    iter(fn: (arg: T) => void): AsyncResult<T>;
    /**
     * Passes the Error value to the given @param fn function. Will only run if the value is Error.
     */
    iterError(fn: (arg: any) => void): AsyncResult<T>;
    /**
     * Wraps a value, promise or result in an AsyncResult monad.
     */
    static wrap<T>(value: T | Result<T> | Promise<T | Result<T>>): AsyncResult<T>;
    /**
     * Gets the underlying promise, which can then be awaited.
     */
    static get<T>(a: AsyncResult<T>): ReturnType<typeof a.get>;
    /**
     * Returns a curried function that will map the OK value to another value. Will only run if the value is OK.
     */
    static map<T, U>(fn: (arg: T) => U): Curried$1<T, AsyncResult<U>>;
    /**
     * Returns a curried function that will map the Error value back to an OK value. Will only run if the value is Error.
     */
    static mapError<T>(fn: (arg: any) => T): Curried$1<T, AsyncResult<T>>;
    /**
     * Returns a curried function that will bind the OK value to the AsyncResult returned by the @param fn function. Will only run if the value is OK.
     */
    static bind<T, U>(fn: (arg: T) => AsyncResult<U>): Curried$1<T, AsyncResult<U>>;
    /**
     * Returns a curried function that will bind the Error value to the AsyncResult returned by the @param fn function. Will only run if the value is Error.
     */
    static bindError<T>(fn: (arg: any) => AsyncResult<T>): Curried$1<T, AsyncResult<T>>;
    /**
     * Returns a curried function that will pass the OK value to the given @param fn function. Will only run if the value is OK.
     */
    static iter<T>(fn: (arg: T) => void): Curried$1<T, AsyncResult<T>>;
    /**
     * Returns a curried function that will pass the Error value to the given @param fn function. Will only run if the value is Error.
     */
    static iterError<T>(fn: (arg: any) => void): Curried$1<T, AsyncResult<T>>;
}

/**
 * A simple function that wraps logic in a computation "block". This is conceptually similar to, and 100% inspired by, the "let" blocks of F#. It's just a simple way to compute the value of a variable using other temporary variables without polluting your scope with those temporary variables, and while keeping the final value immutable (`const`).
 * Example:
 * ```ts
const order = await compute(async () => {
    const displayId = await database.getDisplayIdAsync();
    const order = {
        ...baseOrder,
        user_id: req.user_id,
        display_id: displayId
    }
    const result = await database.createAsync(order);

    return {
        ...order,
        _id: result.id,
        _rev: result.rev
    }
})
```
 * In this example, order is only declared once, and the temporary variables that only it uses (displayId, result) are wrapped up neatly in the computation. Here's the same example without wrapping in a computation:
 * ```ts
const displayId = await database.getDisplayIdAsync();
let order = {
    ...baseOrder,
    user_id: req.user_id,
    display_id: displayId
}
const result = await database.createAsync(order);
order = {
    ...order,
    _id: result.id,
    _rev: result.rev
}
```
 * In this example, order is mutable by default (because its value needs to be reassigned after getting the `result`), and the temporary variables that only it uses are polluting the scope of the rest of the function.
 */
declare function compute<T>(block: () => T): T;

type Curried<T, U> = (option: Option<T>) => U;
declare class Option<T> {
    private readonly value?;
    constructor(value?: T | null | undefined);
    /**
     * Checks whether the value is some.
     */
    isSome: () => boolean;
    /**
     * Checks whether the value is none.
     */
    isNone: () => boolean;
    /**
     * Gets the underlying value. You *must* check whether the value is some or none before getting, as using this on a value that is none **will** throw an error.
     */
    get(): T;
    /**
     * Maps the value to another value. Will only run if the value is some.
     */
    map<U>(mapper: (arg: T) => U): Option<U>;
    /**
     * Binds the value to another option. Will only run if the value is some.
     */
    bind<U>(mapper: (arg: T) => Option<U>): Option<U>;
    /**
     * Passes the value to the given @param fn function where it can the be used for operations that don't require a value to be returned.
     */
    iter(fn: (arg: T) => void): Option<T>;
    /**
     * Executes the given @param fn function when the the option has no value.
     */
    iterNone(fn: () => void): Option<T>;
    /**
     * Returns the @param defaultValue if the option is none, else returns the option's value.
     */
    defaultValue(defaultValue: T): T;
    /**
     * Executes the @param fn function if the value is none and returns the result, else returns the option value itself.
     */
    defaultWith(fn: () => T): T;
    /**
     * Wraps the @param value in an option.
     */
    static ofSome<T>(value: T): Option<T>;
    /**
     * Creates an option with no value.
     */
    static ofNone<T = never>(): Option<T>;
    /**
     * Checks whether the value is some.
     */
    static isSome<T>(option: Option<T>): boolean;
    /**
     * Checks whether the value is none.
     */
    static isNone<T>(option: Option<T>): boolean;
    /**
     * Gets the underlying value. You *must* check whether the value is some or none before getting, as using this on a value that is none **will** throw an error.
     */
    static get<T>(option: Option<T>): T;
    /**
     * Returns a curried function that will map the value to another value. Will only run if the value is some.
     */
    static map<T, U>(mapper: (arg: T) => U): Curried<T, Option<U>>;
    /**
     * Returns a curried function that will bind the value to another option. Will only run if the value is some.
     */
    static bind<T, U>(mapper: (arg: T) => Option<U>): Curried<T, Option<U>>;
    /**
     * Returns a curried function that will pass the value to the given @param fn function where it can the be used for operations that don't require a value to be returned.
     */
    static iter<T>(fn: (arg: T) => void): Curried<T, Option<T>>;
    /**
     * Returns a curried function that executes the given @param fn function when the the option has no value.
     */
    static iterNone<T>(fn: () => void): Curried<T, Option<T>>;
    /**
     * Returns a curried function that will return the @param defaultValue if the option is none, else returns the option's value.
     */
    static defaultValue<T>(defaultValue: T): Curried<T, T>;
    /**
     * Returns a curried function that will execute the @param fn function if the value is none and returns the result, else returns the option's value itself.
     */
    static defaultWith<T>(fn: () => T): Curried<T, T>;
}

interface IPipe<T> {
    readonly value: () => T;
    chain<R>(fn: (x: T) => R): IPipe<R>;
}
/**
 * A simple function chain that pipes the result of the last function to the next function. Since custom operators are impossible, the `pipe` function instead uses `.chain` and `.value`.
 * Note that the functions are executed as they're chained, not when the value is retrieved.
 */
declare function pipe<T>(val: T): IPipe<T>;

export { Async, AsyncResult, IPipe, Option, Result, WrappedResultError, compute, pipe };