/**
 * Represents the result of an operation that can succeed (`Ok`) or fail (`Err`).
 * Inspired by Rust's Result type — makes errors explicit in the type system.
 *
 * @example
 * ```ts
 * function divide(a: number, b: number): Result<number, string> {
 *   if (b === 0) return Err('Division by zero');
 *   return Ok(a / b);
 * }
 *
 * const result = divide(10, 2);
 * result.match({
 *   ok: (value) => console.log(`Result: ${value}`),
 *   err: (error) => console.error(`Error: ${error}`),
 * });
 * ```
 */
export type Result<T, E> = OkResult<T, E> | ErrResult<T, E>;
declare class OkResult<T, E> {
    readonly value: T;
    readonly _tag: "Ok";
    constructor(value: T);
    isOk(): this is OkResult<T, E>;
    isErr(): this is ErrResult<T, E>;
    /** Transform the success value. */
    map<U>(fn: (value: T) => U): Result<U, E>;
    /** Transform the error value (no-op for Ok). */
    mapErr<F>(_fn: (error: E) => F): Result<T, F>;
    /** Chain operations that return a Result (flatMap). */
    andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;
    /** Return this Result if Ok, otherwise return the other. */
    orElse<F>(_fn: (error: E) => Result<T, F>): Result<T, F>;
    /** Get the value, or throw if Err. */
    unwrap(): T;
    /** Get the value, or return a default. */
    unwrapOr(_defaultValue: T): T;
    /** Get the value, or compute a default from the error. */
    unwrapOrElse(_fn: (error: E) => T): T;
    /** Get the error, or throw if Ok. */
    unwrapErr(): E;
    /** Pattern match on the Result. */
    match<U>(handlers: {
        ok: (value: T) => U;
        err: (error: E) => U;
    }): U;
    /** Convert to an Option, discarding the error. */
    ok(): T | undefined;
    /** Convert to an Option of the error (returns undefined for Ok). */
    err(): E | undefined;
    /** Apply a function to the value if Ok, used for side effects. */
    tap(fn: (value: T) => void): Result<T, E>;
    /** Apply a function to the error if Err (no-op for Ok). */
    tapErr(_fn: (error: E) => void): Result<T, E>;
    /** Convert to a JSON-friendly representation. */
    toJSON(): {
        tag: 'Ok';
        value: T;
    };
    toString(): string;
}
declare class ErrResult<T, E> {
    readonly error: E;
    readonly _tag: "Err";
    constructor(error: E);
    isOk(): this is OkResult<T, E>;
    isErr(): this is ErrResult<T, E>;
    map<U>(_fn: (value: T) => U): Result<U, E>;
    mapErr<F>(fn: (error: E) => F): Result<T, F>;
    andThen<U>(_fn: (value: T) => Result<U, E>): Result<U, E>;
    orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F>;
    unwrap(): T;
    unwrapOr(defaultValue: T): T;
    unwrapOrElse(fn: (error: E) => T): T;
    unwrapErr(): E;
    match<U>(handlers: {
        ok: (value: T) => U;
        err: (error: E) => U;
    }): U;
    ok(): T | undefined;
    err(): E | undefined;
    tap(_fn: (value: T) => void): Result<T, E>;
    tapErr(fn: (error: E) => void): Result<T, E>;
    toJSON(): {
        tag: 'Err';
        error: E;
    };
    toString(): string;
}
/**
 * Create a successful Result.
 */
export declare function Ok<T>(value: T): Result<T, never>;
/**
 * Create a failed Result.
 */
export declare function Err<E>(error: E): Result<never, E>;
/**
 * Result namespace with static utility methods.
 */
export declare const ResultUtils: {
    /**
     * Wrap a function that may throw into a Result.
     *
     * @example
     * ```ts
     * const result = Result.from(() => JSON.parse(input));
     * ```
     */
    from<T>(fn: () => T): Result<T, Error>;
    /**
     * Wrap a Promise into a ResultAsync.
     */
    fromPromise<T>(promise: Promise<T>): Promise<Result<T, Error>>;
    /**
     * Collect an array of Results into a Result of an array.
     * Returns the first Err encountered, or Ok with all values.
     */
    all<T, E>(results: Result<T, E>[]): Result<T[], E>;
    /**
     * Check if a value is a Result.
     */
    isResult<T, E>(value: unknown): value is Result<T, E>;
};
export {};
//# sourceMappingURL=result.d.ts.map