/**
 * Result utility pattern for better error handling
 * Provides a functional approach to error handling without exceptions
 */
/**
 * Base Result interface for operations that may succeed or fail
 */
export interface Result<T, E = Error> {
    readonly success: boolean;
    readonly data?: T;
    readonly error?: E;
    isOk(): this is Ok<T>;
    isErr(): this is Err<E>;
    unwrap(): T;
    unwrapOr(defaultValue: T): T;
    map<U>(fn: (value: T) => U): Result<U, E>;
    flatMap<U, F>(fn: (value: T) => Result<U, F>): Result<U, E | F>;
    mapError<F>(fn: (error: E) => F): Result<T, F>;
}
/**
 * Success result
 */
export declare class Ok<T> implements Result<T, never> {
    readonly success = true;
    readonly data: T;
    constructor(data: T);
    map<U>(fn: (value: T) => U): Result<U, never>;
    flatMap<U, F>(fn: (value: T) => Result<U, F>): Result<U, F>;
    mapError<F>(_fn: (error: never) => F): Result<T, F>;
    unwrap(): T;
    unwrapOr(_defaultValue: T): T;
    isOk(): this is Ok<T>;
    isErr(): this is Err<never>;
}
/**
 * Error result
 */
export declare class Err<E> implements Result<never, E> {
    readonly success = false;
    readonly error: E;
    constructor(error: E);
    map<U>(_fn: (value: never) => U): Result<U, E>;
    flatMap<U, F>(_fn: (value: never) => Result<U, F>): Result<U, E | F>;
    mapError<F>(fn: (error: E) => F): Result<never, F>;
    unwrap(): never;
    unwrapOr<T>(defaultValue: T): T;
    isOk(): this is Ok<never>;
    isErr(): this is Err<E>;
}
/**
 * Create a successful result
 */
export declare function ok<T>(data: T): Ok<T>;
/**
 * Create an error result
 */
export declare function err<E>(error: E): Err<E>;
/**
 * Wrap a potentially throwing function in a Result
 */
export declare function tryCatch<T>(fn: () => T): Result<T, Error>;
/**
 * Wrap an async potentially throwing function in a Result
 */
export declare function tryAsync<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;
/**
 * Combine multiple results into a single result
 * Returns Ok with array of all values if all are Ok, otherwise returns first Err
 */
export declare function combine<T, E>(results: Result<T, E>[]): Result<T[], E>;
/**
 * Sequence async results, stopping at the first error
 */
export declare function sequenceAsync<T, E>(promises: Promise<Result<T, E>>[]): Promise<Result<T[], E>>;
/**
 * Apply a function to each element and collect results
 */
export declare function traverse<T, U, E>(items: T[], fn: (item: T) => Result<U, E>): Result<U[], E>;
/**
 * Apply an async function to each element and collect results
 */
export declare function traverseAsync<T, U, E>(items: T[], fn: (item: T) => Promise<Result<U, E>>): Promise<Result<U[], E>>;
/**
 * Partition results into successes and failures
 */
export declare function partition<T, E>(results: Result<T, E>[]): {
    successes: T[];
    failures: E[];
};
/**
 * Type guard for Ok results
 */
export declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
/**
 * Type guard for Err results
 */
export declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
/**
 * Convert a nullable value to a Result
 */
export declare function fromNullable<T>(value: T | null | undefined, error?: Error): Result<T, Error>;
/**
 * Convert a boolean to a Result
 */
export declare function fromBoolean(condition: boolean, error?: Error): Result<true, Error>;
//# sourceMappingURL=result.d.ts.map