type UnwrapResult<T extends Result<any, any> | any> = T extends Result<infer U, any> ? U : T;
type UnwrapError<T extends Result<any, any>> = T extends Result<any, infer E> ? E : never;
export type AsyncResult<S, E> = Promise<Result<S, E>>;
export type TCollectResult<T> = Result<{
    [key in keyof T]: T[key] extends Result<infer A, any> ? A : T[key];
}, {
    [key in keyof T]: T[key] extends Result<any, infer B> ? B : never;
}[keyof {
    [key in keyof T]: T[key] extends Result<any, infer B> ? B : never;
}]>;
export declare class Result<S, E> {
    private _type;
    private _data;
    private _error;
    private constructor();
    /**
     * Produces a Failing Result instance
     * @param error
     * @returns
     */
    static fail<E>(error: E): Result<any, E>;
    /**
     * Produces a Ok Result Instance
     * @param data
     * @returns
     */
    static ok<S>(data: S): Result<S, any>;
    /**
     * Collects a array of Results into a Result of Array,
     * or outputs the first Failing Result.
     * Ignores non-result types from the generated array
     * @param results
     * @returns
     */
    static collect<T, E>(results: Array<Result<T, E>>): Result<T[], E>;
    /**
     * Collects a object os key: Result<T, E> into a Result<key: T, E>, and
     * E being the first Failing result
     * If a object key contains something that's not a Result, the value is kept
     * in the final object Ok
     * @param obj
     * @returns
     */
    static collectObject<T extends Record<string, Result<any, any> | any>>(resultsObject: T): Result<{
        [K in keyof T]: UnwrapResult<T[K]>;
    }, UnwrapError<T[keyof T]>>;
    static isResult(result: any | Result<any, any>): result is Result<any, any>;
    /**
     * Returns True is Result is Ok
     * @returns boolean
     */
    isOk(): boolean;
    /**
     * Returns true is Result is Fail
     * @returns boolean
     */
    isFail(): boolean;
    /**
     * Unwraps the Ok value of a Result. If the Result is Fail, an error is thrown.
     * @returns The success value of the Result.
     * @throws {NoOkValueError} Will throw an error if the Result is Fail.
     */
    unwrap(): S;
    /**
     * Unwraps the Fail value of a Result. If the Result is Ok, an error is thrown.
     * @returns The error value of the Result.
     * @throws {NoFailValueError} Will throw an error if the Result is Ok.
     */
    unwrapFail(): E;
    /**
     * Applies a function into the Ok value of the result while propagating the Fail
     * @param transform
     * @returns
     */
    map<NewS>(transform: (data: S) => NewS): Result<NewS, E>;
    /**
     * Applies a function into the Fail value of the result while propagating the Ok
     * @param transform
     * @returns
     */
    mapFail<NewE>(transform: (error: E) => NewE): Result<S, NewE>;
    /**
     * Applies a function that returns a result into the Ok value of the result, if Failing, can return the original Fail or the new Fail
     * @param transform
     * @returns
     */
    flatMap<NewS, NewE>(transform: (data: S) => Result<NewS, NewE>): Result<NewS, E | NewE>;
    /**
     * Applies a function that returns a result into the Fail value of the result, if Ok, can return the original Ok or the new Ok
     * @param transform
     * @returns
     */
    flatMapFail<NewS, NewE>(transform: (error: E) => Result<NewS, NewE>): Result<S | NewS, NewE>;
    /**
     * Applies a async function into the Ok value of the result while propagating the Fail
     * Returns the Result as a Promise
     * @param transform
     * @returns
     */
    asyncMap<NewS>(transform: (data: S) => Promise<NewS>): Promise<Result<NewS, E>>;
    /**
     * Applies a async function into the Fail value of the result while propagating the Ok
     * Returns the Result as a Promise
     * @param transform
     * @returns
     */
    asyncMapFail<NewE>(transform: (error: E) => Promise<NewE>): Promise<Result<S, NewE>>;
    /**
     * Applies a async function that returns a result into the Ok value of the result, if Failing, can return the original Fail or the new Fail
     * Returns the Result as a Promise
     * @param transform
     * @returns
     */
    asyncFlatMap<NewS, NewE>(transform: (data: S) => Promise<Result<NewS, NewE>>): Promise<Result<NewS, E | NewE>>;
    /**
     * Applies a async function that returns a result into the Fail value of the result, if Ok, can return the original Ok or the new Ok
     * Returns the Result as a Promise
     * @param transform
     * @returns
     */
    asyncFlatMapFail<NewS, NewE>(transform: (error: E) => Promise<Result<NewS, NewE>>): Promise<Result<S | NewS, NewE>>;
}
export declare const Fail: typeof Result.fail;
export declare const Ok: typeof Result.ok;
export {};