/**
 * Minimal implementation of a Maybe monad
 * loosely based on https://github.com/patrickmichalina/typescript-monads/blob/master/src/maybe/maybe.ts
 */
export declare class Maybe<T> {
    private _value;
    private _isNone;
    constructor(value?: T | null);
    static of<T>(value?: T): Maybe<T>;
    static ofFalsy<T>(value?: T): Maybe<NonNullable<T>>;
    get isSome(): boolean;
    valueOr<U>(defaultValue: U): T | U;
    map<U>(fn: (value: NonNullable<T>) => U): Maybe<U>;
    mapOr<U>(defaultValue: U, fn: (value: NonNullable<T>) => U): U;
    mapOrUndefined<U>(fn: (value: NonNullable<T>) => U): U | undefined;
    mapOrNull<U>(fn: (value: NonNullable<T>) => U): U | null;
}
/**
 * Minimal implementation of an Either monad
 */
export declare class Either<L, R> {
    private _value;
    private _isLeft;
    constructor(isLeft: boolean, value: L | R);
    static left<L, R>(value: L): Either<L, R>;
    static right<L, R>(value: R): Either<L, R>;
    isLeft(): boolean;
    isRight(): boolean;
    left(): L | undefined;
    right(): R | undefined;
    map<R2>(fn: (value: R) => R2): Either<L, R2>;
    mapLeft<L2>(fn: (value: L) => L2): Either<L2, R>;
    flatMap<L2, R2>(fn: (value: R) => Either<L2, R2>): Either<L | L2, R2>;
    fold<U>(onLeft: (value: L) => U, onRight: (value: R) => U): U;
    value(): L | R;
}
/**
 * Minimal implementation of a Result monad that wraps an Either
 */
export declare class Result<T, E> extends Either<E, T> {
    constructor(either: Either<E, T>);
    static ok<T, E>(value: T): Result<T, E>;
    static error<T, E>(value: E): Result<T, E>;
    static fromEither<T, E>(either: Either<E, T>): Result<T, E>;
    ok(): T | undefined;
    error(): E | undefined;
    mapError<E2>(fn: (value: E) => E2): Result<T, E2>;
    flatMap<L, R>(fn: (value: T) => Either<L, R>): Result<R, L | E>;
}