/**
 * Result Type for Functional Error Handling
 *
 * Provides a type-safe alternative to try/catch for operations that can fail.
 * Encourages explicit error handling at compile time.
 */
/**
 * Represents the result of an operation that can succeed or fail
 */
export type Result<T, E = Error> = {
    readonly success: true;
    readonly data: T;
} | {
    readonly success: false;
    readonly error: E;
};
/**
 * Create a successful result
 */
export declare function ok<T>(data: T): Result<T, never>;
/**
 * Create a failed result
 */
export declare function err<E>(error: E): Result<never, E>;
/**
 * Check if result is successful
 */
export declare function isOk<T, E>(result: Result<T, E>): result is {
    success: true;
    data: T;
};
/**
 * Check if result is an error
 */
export declare function isErr<T, E>(result: Result<T, E>): result is {
    success: false;
    error: E;
};
/**
 * Unwrap a result, throwing if it's an error
 */
export declare function unwrap<T, E>(result: Result<T, E>): T;
/**
 * Unwrap a result with a default value
 */
export declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
/**
 * Map over a successful result
 */
export declare function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
/**
 * Map over an error result
 */
export declare function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
/**
 * Chain results (flatMap)
 */
export declare function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
/**
 * Convert a promise to a Result
 */
export declare function fromPromise<T>(promise: Promise<T>): Promise<Result<T, Error>>;
/**
 * Convert a function that might throw to one that returns Result
 */
export declare function tryCatch<T>(fn: () => T): Result<T, Error>;
/**
 * Combine multiple results into one
 */
export declare function all<T, E>(results: Result<T, E>[]): Result<T[], E>;
//# sourceMappingURL=result.d.ts.map