import { type Result } from './result.js';
import { type Option } from './option.js';
/**
 * A Result wrapped in a Promise, with chainable async operations.
 *
 * @example
 * ```ts
 * const result = ResultAsync.from(fetch('/api/user'))
 *   .map(res => res.json())
 *   .mapErr(err => new ApiError(err.message));
 * ```
 */
export declare class ResultAsync<T, E> {
    private readonly promise;
    constructor(promise: Promise<Result<T, E>>);
    /**
     * Create from a Promise that may reject.
     */
    static from<T>(promise: Promise<T>): ResultAsync<T, Error>;
    /**
     * Create from a Result.
     */
    static fromResult<T, E>(result: Result<T, E>): ResultAsync<T, E>;
    /**
     * Create an Ok ResultAsync.
     */
    static ok<T>(value: T): ResultAsync<T, never>;
    /**
     * Create an Err ResultAsync.
     */
    static err<E>(error: E): ResultAsync<never, E>;
    /** Transform the success value. */
    map<U>(fn: (value: T) => U): ResultAsync<U, E>;
    /** Transform the error value. */
    mapErr<F>(fn: (error: E) => F): ResultAsync<T, F>;
    /** Chain async operations. */
    andThen<U>(fn: (value: T) => ResultAsync<U, E>): ResultAsync<U, E>;
    /** Extract the underlying Promise<Result>. */
    toPromise(): Promise<Result<T, E>>;
    /** Unwrap or throw. */
    unwrap(): Promise<T>;
    /** Unwrap or return default. */
    unwrapOr(defaultValue: T): Promise<T>;
    /** Pattern match on the resolved Result. */
    match<U>(handlers: {
        ok: (value: T) => U;
        err: (error: E) => U;
    }): Promise<U>;
}
/**
 * An Option wrapped in a Promise.
 */
export declare class OptionAsync<T> {
    private readonly promise;
    constructor(promise: Promise<Option<T>>);
    /**
     * Create from a Promise that resolves to a nullable value.
     */
    static from<T>(promise: Promise<T | null | undefined>): OptionAsync<T>;
    static some<T>(value: T): OptionAsync<T>;
    static none<T = never>(): OptionAsync<T>;
    map<U>(fn: (value: T) => U): OptionAsync<U>;
    andThen<U>(fn: (value: T) => OptionAsync<U>): OptionAsync<U>;
    toPromise(): Promise<Option<T>>;
    unwrap(): Promise<T>;
    unwrapOr(defaultValue: T): Promise<T>;
    match<U>(handlers: {
        some: (value: T) => U;
        none: () => U;
    }): Promise<U>;
}
//# sourceMappingURL=async.d.ts.map