/**
 * Result type implementation inspired by Rust's Result<T, E>
 * Provides a type-safe way to handle success and error cases.
 *
 * Available methods:
 * - `isOk()` / `isErr()` - Check if operation succeeded or failed
 * - `unwrap()` - Get the value (throws if error)
 * - `unwrapOr(default)` - Get value or return default
 */
interface IResult<T, E> {
    isOk(): this is Ok<T, E>;
    isErr(): this is Err<T, E>;
    unwrap(): T;
    unwrapOr(defaultValue: T): T;
    unwrapErr(): E;
}
declare class Ok<T, E> implements IResult<T, E> {
    readonly value: T;
    constructor(value: T);
    isOk(): this is Ok<T, E>;
    isErr(): this is Err<T, E>;
    unwrap(): T;
    unwrapOr(_defaultValue: T): T;
    unwrapErr(): E;
}
declare class Err<T, E> implements IResult<T, E> {
    readonly error: E;
    constructor(error: E);
    isOk(): this is Ok<T, E>;
    isErr(): this is Err<T, E>;
    unwrap(): T;
    unwrapOr(defaultValue: T): T;
    unwrapErr(): E;
}
type Result<T, E = Error> = Ok<T, E> | Err<T, E>;
/**
 * Creates a successful Result containing the given value.
 */
declare function ok<T, E = Error>(value: T): Result<T, E>;
/**
 * Creates a failed Result containing the given error.
 */
declare function err<T, E = Error>(error: E): Result<T, E>;
/**
 * Wraps a function that might throw into a Result.
 */
declare function tryCatch<T, E = Error>(fn: () => T): Result<T, E>;
/**
 * Wraps an async function that might throw into a Promise<Result>.
 */
declare function tryCatchAsync<T, E = Error>(fn: () => Promise<T>): Promise<Result<T, E>>;
export { Ok, Err, Result, ok, err, tryCatch, tryCatchAsync };