/**
 * Result Type Implementation
 *
 * Implements the Result<T, E> pattern for explicit error handling.
 * Follows guardrails.md requirements for functional error handling.
 * Part of Layer 3 (Business Logic & Execution)
 */
/**
 * Successful result variant
 */
export interface Ok<T> {
    readonly ok: true;
    readonly value: T;
}
/**
 * Error result variant
 */
export interface Err<E> {
    readonly ok: false;
    readonly error: E;
}
/**
 * Result type for explicit error handling
 * Use this instead of throwing exceptions for expected errors
 */
export type Result<T, E> = Ok<T> | Err<E>;
/**
 * Create a successful result
 * @param value - The success value
 * @returns Ok<T> result
 */
export declare function ok<T>(value: T): Ok<T>;
/**
 * Create an error result
 * @param error - The error value
 * @returns Err<E> result
 */
export declare function err<E>(error: E): Err<E>;
/**
 * Type guard to check if result is Ok
 * @param result - The result to check
 * @returns true if result is Ok<T>
 */
export declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
/**
 * Type guard to check if result is Err
 * @param result - The result to check
 * @returns true if result is Err<E>
 */
export declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
/**
 * Unwrap a result, returning the value or throwing the error
 * @param result - The result to unwrap
 * @returns The value if Ok
 * @throws The error if Err
 */
export declare function unwrap<T, E>(result: Result<T, E>): T;
/**
 * Unwrap a result with a default value
 * @param result - The result to unwrap
 * @param defaultValue - Value to return if Err
 * @returns The value if Ok, defaultValue if Err
 */
export declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
/**
 * Map the success value of a result
 * @param result - The result to map
 * @param fn - Function to transform the value
 * @returns New result with transformed value
 */
export declare function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
/**
 * Map the error value of a result
 * @param result - The result to map
 * @param fn - Function to transform the error
 * @returns New result with transformed error
 */
export declare function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
/**
 * Flat map (chain) operations on results
 * @param result - The result to flatMap
 * @param fn - Function returning a Result
 * @returns Flattened Result
 */
export declare function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
//# sourceMappingURL=result.d.ts.map