import * as V from '@prelude/validation';
export type Ok<T> = {
    status: 'ok';
    value: T;
};
export type Fail = {
    status: 'refuted';
    reason: string;
    received: unknown;
};
export type Result<T> = Ok<T> | Fail;
export type Refute<T> = (value: unknown) => Result<T>;
export type Refuted<P> = P extends Refute<infer U> ? U : never;
export type Primitive = undefined | null | false | true | number | bigint | string | symbol | RegExp;
export type Lifted<T> = T extends Refute<infer U> ? U : T extends Primitive ? T : never;
export type IntersectionOfUnion<T> = (T extends unknown ? (_: T) => unknown : never) extends (_: infer R) => unknown ? R : never;
export type Constructor = abstract new (...args: any) => any;
export declare const parameter0 = "@prelude/refute:parameter0";
/** @returns success result. */
export declare const ok: <T>(value: T) => Ok<T>;
/** @returns failure result. */
export declare const fail: (received: unknown, reason: string) => Fail;
/** @returns `true` if provided `result` is failure, `false` otherwise. */
export declare const failed: (result: Result<unknown>) => result is Fail;
/** Wraps failure with provided `reason` prefix. */
export declare const refail: (failure: Fail, reason: string) => Fail;
export declare const nest: <T>(reason: string) => (a: Refute<T>) => Refute<T>;
/** @return failure reason without inspecting received value. */
export declare const reasonWithoutReceived: (failure: Fail) => string;
/** @return failure reason with inspecting received value. */
export declare const reasonWithReceived: (failure: Fail) => string;
/** Renders what a core failure expected in this package's words (without the path). */
export declare const expectedReason: (expected: V.Expected, index?: number) => string;
/** Turns a core failure into this package's `Fail`. */
export declare const toFail: (failure: V.Failure) => Fail;
/** The core validator behind a refute (or a primitive): built-ins carry theirs, custom refutes are adapted. */
export declare const toValidator: (a: Primitive | Refute<unknown>) => V.Validator<unknown>;
/** A refute over a core validator. */
export declare const refuting: <T>(validator: V.Validator<T>) => Refute<T>;