export interface ErrorLike {
    message: string;
    name?: string;
}
export declare const isErrorLike: (value: unknown) => value is ErrorLike;
interface Pass<T> {
    ok: true;
    value: T;
}
interface Fail<E = Error> {
    ok: false;
    error: E;
}
/**
 * This type represents the outcome of an operation that can either
 * succeed or fail.
 */
export type Result<T, E = Error> = Pass<T> | Fail<E>;
declare function pass(): Pass<void>;
declare function pass<T>(value: T): Pass<T>;
export declare const RESULT: {
    /**
     * Creates a successful Result.
     *
     * No argument has to be passed to the method if it is void.
     * I.e. both of these are valid:
     *
     * Result.pass(42) // Result<number>
     * Result.pass() // Result<void>
     */
    pass: typeof pass;
    /**
     * Creates a failed Result.
     */
    fail<E = Error>(error: E): Fail<E>;
};
/**
 * unwrap returns the value form result, if result is Pass<T>, or the
 * default value.
 *
 * @param result the {@link Result} to unwrap
 * @param defaultValue the value to return if `result` is not {@link Pass}
 * @returns The unwrapped result or the default value
 */
export declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
export {};