import { EitherInterface } from './interfaces/either.interface';
import { Right } from './right';
/**
 * @class Left
 */
export declare class Left<T> implements EitherInterface<T> {
    /**
     * Lift a value into Either.
     * @param {TNewValue} x
     * @returns {Left<TNewValue>}
     */
    static of<TNewValue>(x: TNewValue): Left<TNewValue>;
    /**
     * @returns {any}
     */
    static readonly [Symbol.species]: any;
    /**
     * Internally stored value.
     */
    protected readonly _value: T;
    /**
     * @constructor
     * @param {T} x
     */
    constructor(x: T);
    /**
     * Apply the function value of current Either to another Either.
     * @param {Left<TAnotherValue>} v
     * @returns {Left<TNewValue>}
     */
    ap<TAnotherValue, TNewValue>(v: EitherInterface<TAnotherValue>): Left<TNewValue>;
    /**
     * Transform the Left value of the Either using a unary function to monad.
     * @param {(x: T) => Left<TNewValue>} f
     * @returns {Left<TNewValue>}
     */
    chain<TNewValue>(f: (x: T) => EitherInterface<TNewValue>): Left<TNewValue>;
    /**
     * Concat the Left value of the Either with another Left or keep Left on either side.
     * @param {Left<T>} x
     * @returns {Left<T>}
     */
    concat<TAnother>(x: EitherInterface<TAnother>): Left<TAnother>;
    /**
     * Transform internal value of the either.
     * @param {(e: T) => TNewResult} f
     * @returns {FunctorInterface<TNewResult>}
     */
    map<TAnother, TNewResult>(f: (e: T) => TNewResult): Left<TNewResult>;
    /**
     * Lift a value into Either.
     * @param {TNewValue} x
     * @returns {Left<TNewValue>}
     */
    of<TNewValue>(x: TNewValue): Left<TNewValue>;
    /**
     * Unsafely get internal value of the Either.
     * @returns {T}
     */
    unsafeGet(): T;
    /**
     * Swap disjunction values.
     * @returns {Right<T>}
     */
    swap(): Right<T>;
    /**
     * Get value fot the Either if in its Leftmost case or run provided function.
     * @param {(x: T) => TNewResult} f
     * @returns {T}
     */
    getOrElse<TNewResult>(f: (x?: T) => TNewResult): TNewResult;
    /**
     * Safely get value of the Either.
     * @param {<TLeftResult>(x: T) => TLeftResult} f
     * @param {<TLeftResult>(x: T) => TLeftResult} g
     * @returns {any}
     */
    fold<TLeftResult>(f: (x: T) => TLeftResult, g: (x: T) => any): TLeftResult;
    /**
     * Test if the Either equals another Either.
     * @param {Left<T | TAnother>} x
     * @returns {boolean}
     */
    equals<TAnother>(x: Left<T | TAnother>): boolean;
    /**
     * Approval for Either to be Left.
     * @returns {boolean}
     */
    readonly isRight: boolean;
    /**
     * Approval for Either to be Left.
     * @returns {boolean}
     */
    readonly isLeft: boolean;
    /**
     * @returns {string}
     */
    toString(): string;
}