/**
 * Discriminated union representing either a successful result (Ok) or an error (Err).
 *
 * @template Ok Type of successful value
 * @template Err Type of error value
 */
export type Result<Ok, Err> = Success<Ok> | Failure<Err>;
/**
 * Represents a successful operation result.
 *
 * @template T Type of the contained value.
 */
export type Success<T> = {
    readonly $type: "ok";
    readonly value: T;
};
/**
 * Represents a failed operation result.
 *
 * @template T Type of the error information.
 */
export type Failure<T> = {
    readonly $type: "err";
    readonly err: T;
};
/**
 * Creates a Success result with the given value.
 *
 * @example
 * const result: Result<number, never> = Ok(42);
 */
export declare const Ok: <T>(value: T) => Result<T, never>;
/**
 * Creates a Failure result with the given error.
 *
 * @example
 * const error: Result<never, string> = Err("File not found");
 */
export declare const Err: <T>(err: T) => Result<never, T>;
export declare namespace Result {
    type Successes<T> = T extends Success<unknown> ? T : never;
    type Failures<T> = T extends Failure<unknown> ? T : never;
    /**
     * Type guard for Success results.
     *
     * @param v Result to check
     * @returns true if the result is a Success
     */
    const isOk: <Ok, Err>(v: Result<Ok, Err>) => v is Success<Ok>;
    /**
     * Type guard for Failure results.
     *
     * @param v Result to check
     * @returns true if the result is a Failure
     */
    const isErr: <Ok, Err>(v: Result<Ok, Err>) => v is Failure<Err>;
    /**
     * Type guard that checks if a value is a valid Result.
     *
     * @param v Unknown value to check
     * @returns true if the value is either Success or Failure
     */
    const is: (v: unknown) => v is Result<unknown, unknown>;
    /**
     * Transforms a Success value while preserving error state.
     *
     * @template Ok  Original success type
     * @template Ok2 New success type
     * @template Err Error type
     *
     * @param v Result to transform
     * @param fn Transformation function for success values
     * @returns New Result with transformed value or original error
     *
     * @example
     * const numResult = Ok(42);
     * const strResult = Result.map(numResult, n => n.toString());
     */
    const map: <Ok, Err, Ok2>(v: Result<Ok, Err>, fn: (v: Ok) => Ok2) => Result<Ok2, Err>;
    /**
     * Chains Result-producing operations.
     *
     * @template Ok   Original success type
     * @template Err  Original errors
     * @template Ok2  New success type
     * @template Err2 New errors
     *
     * @param v Initial Result value
     * @param fn Function that returns a new Result
     * @returns Combined Result from the operation chain
     *
     * @example
     * const result = Result.flatMap(Ok(42), n => n > 0 ? Ok(n) : Err("Negative"));
     */
    const flatMap: <Ok, Err, Ok2, Err2>(v: Result<Ok, Err>, fn: (v: Ok) => Result<Ok2, Err2>) => Result<Ok2, Err | Err2>;
    /**
     * Transforms an Error value while preserving success state.
     *
     * @template Ok  Success type
     * @template Err Original error type
     * @template Err2 New error type
     *
     * @param v Result to transform
     * @param fn Transformation function for error values
     * @returns New Result with original value or transformed error
     *
     * @example
     * const errResult = Err("error");
     * const newErrResult = Result.mapErr(errResult, e => e.toUpperCase());
     */
    const mapErr: <Ok, Err, Err2>(v: Result<Ok, Err>, fn: (v: Err) => Err2) => Result<Ok, Err2>;
    /**
     * Chains error-handling operations that may produce new errors.
     *
     * @template Ok   Success type
     * @template Err  Original error type
     * @template Err2 New error type
     *
     * @param v Initial Result value
     * @param fn Function that returns a new Result error
     * @returns Combined Result from the error-handling chain
     *
     * @example
     * const result = Result.flatMapErr(Err("error"), e => Err(e.toUpperCase()));
     */
    const flatMapErr: <Ok, Err, Err2>(v: Result<Ok, Err>, fn: (v: Err) => Result<Ok, Err2>) => Result<Ok, Err2>;
    /**
     * Extracts the success value if Ok, otherwise computes a fallback value.
     *
     * @template Ok   Success type
     * @template Err  Error type
     * @template Out  Return type (Ok or fallback type)
     *
     * @param v Result to extract from
     * @param fn Fallback function that computes a value if Result is Err
     * @returns The success value or the result of the fallback function
     *
     * @example
     * const result = Result.orElse(Ok(42), () => 0);
     * // => 42
     *
     * @example
     * const result = Result.orElse(Err("error"), () => 0);
     * // => 0
     */
    const orElse: <Ok, Err, Out>(v: Result<Ok, Err>, fn: (err: Err) => Out) => Ok | Out;
    /**
     * Converts a synchronous function's return value to a Result type.
     *
     * @param fn Function to execute
     * @returns Result containing:
     * - Original Result if function returns one
     * - Success with return value for non-Result returns
     *
     * @example
     * getUserFromDB // () => User
     * const getUser = () => Result.from(() => getUserFromDB()); // Result<User, never>
     */
    const from: <T>(fn: () => T) => Result<T extends Success<infer Ok> ? Ok : T extends Failure<any> ? never : T, T extends Failure<infer Err> ? Err : never>;
    const fromAsync: <T>(fn: () => T | Promise<T>) => Promise<Result<T extends Success<infer Ok> ? Ok : T extends Failure<any> ? never : T, T extends Failure<infer Err> ? Err : never>>;
    const tryCatch: <T, Err = unknown>(fn: () => T, handler?: (e: unknown) => Err) => Success<T> | Failure<Err>;
    const tryCatchAsync: <T, Err = unknown>(fn: () => T | Promise<T>, handler?: (e: unknown) => Err) => Promise<Success<Awaited<T>> | Failure<Err>>;
}
export type Successes<T> = T extends Success<infer Ok> ? Ok : never;
export type Failures<T> = T extends Failure<infer Err> ? Err : never;