import { EitherInterface } from './interfaces/either.interface';
import { Left } from './left';
/**
 * @class Right
 */
export declare class Right<T> implements EitherInterface<T> {
    /**
     * Lift a value into Either.
     * @param {TNewValue} x
     * @returns {Right<TNewValue>}
     */
    static of<TNewValue>(x: TNewValue): Right<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 {Right<TAnotherValue>} v
     * @returns {Right<TNewValue>}
     */
    ap<TAnotherValue, TNewValue>(v: EitherInterface<TAnotherValue>): EitherInterface<TNewValue>;
    /**
     * Transform the Right value of the Either using a unary function to monad.
     * @param {(x: T) => Right<TNewValue>} f
     * @returns {Right<TNewValue>}
     */
    chain<TNewValue>(f: (x: T) => EitherInterface<TNewValue>): EitherInterface<TNewValue>;
    /**
     * Concat the Right value of the Either with another Right or keep Left on either side.
     * @param {Right<T>} x
     * @returns {Right<T>}
     */
    concat<TAnother>(x: EitherInterface<TAnother>): Right<TAnother>;
    /**
     * Transform internal value of the either.
     * @param {(e: T) => TNewResult} f
     * @returns {FunctorInterface<TNewResult>}
     */
    map<TAnother, TNewResult>(f: (x: T) => TNewResult): Right<TNewResult>;
    /**
     * Lift a value into Either.
     * @param {TNewValue} x
     * @returns {Right<TNewValue>}
     */
    of<TNewValue>(x: TNewValue): Right<TNewValue>;
    /**
     * Unsafely get internal value of the Either.
     * @returns {T}
     */
    unsafeGet(): T;
    /**
     * Swap disjunction values.
     * @returns {Left<T>}
     */
    swap(): Left<T>;
    /**
     * Get value fot the Either if in its Rightmost 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 {<TRightResult>(x: T) => TRightResult} g
     * @returns {any}
     */
    fold<TRightResult>(f: (x: T) => any, g: (x: T) => TRightResult): TRightResult;
    /**
     * Test if the Either equals another Either.
     * @param {Right<T | TAnother>} x
     * @returns {boolean}
     */
    equals<TAnother>(x: Right<T | TAnother>): boolean;
    /**
     * Approval for Either to be Right.
     * @returns {boolean}
     */
    readonly isRight: boolean;
    /**
     * Approval for Either to be Left.
     * @returns {boolean}
     */
    readonly isLeft: boolean;
    /**
     * @returns {string}
     */
    toString(): string;
}