import { Maybe } from "@tsplus/stdlib/data/Maybe/definition";
/**
 * @tsplus type Result
 */
export type Result<W, E, A> = Success<A> | SuccessWithWarning<W, A> | Failure<E>;
/**
 * @tsplus type ResultOps
 */
export interface ResultOps {
}
export declare const Result: ResultOps;
export declare const _T: unique symbol;
export type _T = typeof _T;
/**
 * @tsplus type Result/Success
 */
export interface Success<A> {
    readonly [_T]?: {
        _W: (_: never) => never;
        _E: (_: never) => never;
        _A: (_: never) => A;
    };
    readonly _tag: "Success";
    readonly success: A;
}
/**
 * @tsplus type Result/SuccessWithWarning
 */
export interface SuccessWithWarning<W, A> {
    readonly [_T]?: {
        _W: (_: never) => W;
        _E: (_: never) => never;
        _A: (_: never) => A;
    };
    readonly _tag: "SuccessWithWarning";
    readonly success: A;
    readonly warning: W;
}
/**
 * @tsplus type Result/Failure
 */
export interface Failure<E> {
    readonly [_T]?: {
        _W: (_: never) => never;
        _E: (_: never) => E;
        _A: (_: never) => never;
    };
    readonly _tag: "Failure";
    readonly failure: E;
}
/**
 * @tsplus unify Result/Success
 * @tsplus unify Result/SuccessWithWarning
 * @tsplus unify Result/Failure
 */
export declare function unifyResult<X extends Result<any, any, any>>(self: X): Result<[
    X
] extends [
    {
        readonly [_T]?: {
            _W: (_: never) => infer W;
            _E: (_: never) => infer E;
            _A: (_: never) => infer A;
        };
    }
] ? W : never, [
    X
] extends [
    {
        readonly [_T]?: {
            _W: (_: never) => infer W;
            _E: (_: never) => infer E;
            _A: (_: never) => infer A;
        };
    }
] ? E : never, [
    X
] extends [
    {
        readonly [_T]?: {
            _W: (_: never) => infer W;
            _E: (_: never) => infer E;
            _A: (_: never) => infer A;
        };
    }
] ? A : never>;
/**
 * @tsplus fluent Result fold
 * @tsplus location "@tsplus/runtime/Result"
 */
export declare function fold<W, E, A, T0, T1>(self: Result<W, E, A>, onSuccess: (a: A, w: Maybe<W>) => T0, onFailure: (e: E) => T1): T0 | T1;
/**
 * @tsplus static ResultOps success
 * @tsplus location "@tsplus/runtime/Result"
 */
export declare function success<A>(result: A): Result<never, never, A>;
export declare function success<A, W>(result: A, warning: Maybe<W>): Result<W, never, A>;
/**
 * @tsplus static ResultOps fail
 * @tsplus location "@tsplus/runtime/Result"
 */
export declare function fail<E>(error: E): Result<never, E, never>;
/**
 * @tsplus static ResultOps successWithWarning
 * @tsplus location "@tsplus/runtime/Result"
 */
export declare function successWithWarning<W, A>(result: A, warning: W): Result<W, never, A>;
/**
 * @tsplus fluent Result isSuccess
 * @tsplus location "@tsplus/runtime/Result"
 */
export declare function isSuccess<W, E, A>(self: Result<W, E, A>): self is Success<A>;
/**
 * @tsplus fluent Result isFailure
 * @tsplus location "@tsplus/runtime/Result"
 */
export declare function isFailure<W, E, A>(self: Result<W, E, A>): self is Failure<E>;
/**
 * @tsplus fluent Result isSuccessWihWarning
 * @tsplus location "@tsplus/runtime/Result"
 */
export declare function isSuccessWihWarning<W, E, A>(self: Result<W, E, A>): self is SuccessWithWarning<W, A>;
/**
 * @tsplus fluent Result getSuccess
 * @tsplus location "@tsplus/runtime/Result"
 */
export declare function getSuccess<W, E, A>(self: Result<W, E, A>): import("@tsplus/stdlib/data/Maybe").Maybe<A>;
/**
 * @tsplus fluent Result getFailure
 * @tsplus location "@tsplus/runtime/Result"
 */
export declare function getFailure<W, E, A>(self: Result<W, E, A>): import("@tsplus/stdlib/data/Maybe").Maybe<E>;
/**
 * @tsplus fluent Result getWarning
 * @tsplus location "@tsplus/runtime/Result"
 */
export declare function getWarning<W, E, A>(self: Result<W, E, A>): import("@tsplus/stdlib/data/Maybe").Maybe<W>;
/**
 * @tsplus fluent Result getWarningOrFailure
 * @tsplus location "@tsplus/runtime/Result"
 */
export declare function getWarningOrError<W, E, A>(self: Result<W, E, A>): import("@tsplus/stdlib/data/Maybe").Maybe<import("@tsplus/stdlib/data/Either").Either<W, E>>;
/**
 * @tsplus fluent Result map
 * @tsplus location "@tsplus/runtime/Result"
 */
export declare function map_<W, E, A, B>(self: Result<W, E, A>, f: (a: A) => B): Result<W, E, B>;
//# sourceMappingURL=Result.d.ts.map