/**
 * Result pattern for handling operations that might fail
 * Provides type-safe error handling without exceptions
 */
export declare abstract class Result<T, E = Error> {
    /**
     * Check if result is successful
     */
    abstract get isSuccess(): boolean;
    /**
     * Check if result is failed
     */
    abstract get isFailure(): boolean;
    /**
     * Get the success value (throws if failed)
     */
    abstract get value(): T;
    /**
     * Get the error value (throws if successful)
     */
    abstract get error(): E;
    /**
     * Create a successful result
     */
    static success<T, E = Error>(value: T): Result<T, E>;
    /**
     * Create a failed result
     */
    static failure<T, E = Error>(error: E): Result<T, E>;
    /**
     * Get the success value or a default
     */
    getOrDefault(defaultValue: T): T;
    /**
     * Get the success value or throw the error
     */
    getOrThrow(): T;
    /**
     * Transform successful result
     */
    map<U>(fn: (value: T) => U): Result<U, E>;
    /**
     * Transform failed result
     */
    mapError<F>(fn: (error: E) => F): Result<T, F>;
    /**
     * Chain operations
     */
    flatMap<U>(fn: (value: T) => Result<U, E>): Result<U, E>;
}
/**
 * Internal function to set implementations
 * @internal
 */
export declare function _setResultImplementations(successFactory: <T, E>(value: T) => Result<T, E>, failureFactory: <T, E>(error: E) => Result<T, E>): void;
//# sourceMappingURL=Result.d.ts.map