/**
 * @fileoverview Result type for functional error handling without exceptions.
 */
/**
 * Result type representing either success (Ok) or failure (Err).
 */
export type Result<T, E = Error> = Ok<T> | Err<E>;
/**
 * Successful result containing a value.
 */
export declare class Ok<T> {
    readonly kind: "ok";
    readonly value: T;
    constructor(value: T);
    /**
     * Chain another result-returning operation.
     */
    andThen<U, F>(fn: (_value: T) => Result<U, F>): Result<U, F>;
    /**
     * Check if this result is an error.
     */
    isErr(): boolean;
    /**
     * Check if this result is successful.
     */
    isOk(): this is Ok<T>;
    /**
     * Transform the success value.
     */
    map<U>(fn: (_value: T) => U): Result<U, never>;
    /**
     * Transform the error (no-op for Ok).
     */
    mapErr<F>(_fn: (_error: never) => F): Result<T, F>;
    /**
     * Return this result or the other if error (no-op for Ok).
     */
    orElse<U>(_fn: (_error: never) => Result<U, never>): Result<T | U, never>;
    /**
     * Get the success value or throw if error.
     */
    unwrap(): T;
    /**
     * Get the success value or return default if error.
     */
    unwrapOr(_defaultValue: T): T;
    /**
     * Get the success value or compute from error if error.
     */
    unwrapOrElse(_fn: (_error: never) => T): T;
}
/**
 * Error result containing an error.
 */
export declare class Err<E = Error> {
    readonly kind: "err";
    readonly error: E;
    constructor(error: E);
    /**
     * Chain another result-returning operation (no-op for Err).
     */
    andThen<U, F>(_fn: (_value: never) => Result<U, F>): Result<U, E | F>;
    /**
     * Check if this result is an error.
     */
    isErr(): this is Err<E>;
    /**
     * Check if this result is successful.
     */
    isOk(): boolean;
    /**
     * Transform the success value (no-op for Err).
     */
    map<U>(_fn: (_value: never) => U): Result<U, E>;
    /**
     * Transform the error.
     */
    mapErr<F>(fn: (_error: E) => F): Result<never, F>;
    /**
     * Return this result or the other if error.
     */
    orElse<T, F>(fn: (_error: E) => Result<T, F>): Result<T, F>;
    /**
     * Get the success value or throw if error.
     */
    unwrap(): never;
    /**
     * Get the success value or return default if error.
     */
    unwrapOr<T>(defaultValue: T): T;
    /**
     * Get the success value or compute from error if error.
     */
    unwrapOrElse<T>(fn: (_error: E) => T): T;
}
/**
 * Create a successful result.
 */
export declare function ok<T>(value: T): Ok<T>;
/**
 * Create an error result.
 */
export declare function err<E = Error>(error: E): Err<E>;
/**
 * Utility functions for working with Results.
 */
export declare const ResultUtils: {
    /**
     * Convert all Results to Ok values or return first error.
     */
    all<T extends readonly Result<unknown, unknown>[]>(results: T): Result<{ [K in keyof T]: T[K] extends Result<infer U, any> ? U : never; }, T[number] extends Result<any, infer E> ? E : never>;
    /**
     * Return the first Ok result or the last error.
     * Returns an error result if the input array is empty.
     */
    any<T extends readonly Result<unknown, unknown>[]>(results: T): T[number];
    /**
     * Create an error result.
     */
    err: typeof err;
    /**
     * Wrap a function that might throw into a Result.
     */
    from<T>(fn: () => T): Result<T, Error>;
    /**
     * Create a successful result.
     */
    ok: typeof ok;
};