/**
 * Represents a value that may or may not exist.
 * Eliminates null/undefined bugs by making optionality explicit.
 *
 * @example
 * ```ts
 * const user = Option.from(getUserById(id));
 * const name = user.map(u => u.name).unwrapOr('Anonymous');
 * ```
 */
export type Option<T> = SomeOption<T> | NoneOption<T>;
declare class SomeOption<T> {
    readonly value: T;
    readonly _tag: "Some";
    constructor(value: T);
    isSome(): this is SomeOption<T>;
    isNone(): this is NoneOption<T>;
    /** Transform the contained value. */
    map<U>(fn: (value: T) => U): Option<U>;
    /** Chain operations that return an Option (flatMap). */
    andThen<U>(fn: (value: T) => Option<U>): Option<U>;
    /** Return this Option if Some, otherwise return the other. */
    orElse(_fn: () => Option<T>): Option<T>;
    /** Get the value, or throw if None. */
    unwrap(): T;
    /** Get the value, or return a default. */
    unwrapOr(_defaultValue: T): T;
    /** Get the value, or compute a default. */
    unwrapOrElse(_fn: () => T): T;
    /** Pattern match on the Option. */
    match<U>(handlers: {
        some: (value: T) => U;
        none: () => U;
    }): U;
    /** Filter: return None if the predicate fails. */
    filter(predicate: (value: T) => boolean): Option<T>;
    /** Apply a side-effect function if Some. */
    tap(fn: (value: T) => void): Option<T>;
    /** Zip with another Option. */
    zip<U>(other: Option<U>): Option<[T, U]>;
    toJSON(): {
        tag: 'Some';
        value: T;
    };
    toString(): string;
}
declare class NoneOption<T> {
    readonly _tag: "None";
    isSome(): this is SomeOption<T>;
    isNone(): this is NoneOption<T>;
    map<U>(_fn: (value: T) => U): Option<U>;
    andThen<U>(_fn: (value: T) => Option<U>): Option<U>;
    orElse(fn: () => Option<T>): Option<T>;
    unwrap(): T;
    unwrapOr(defaultValue: T): T;
    unwrapOrElse(fn: () => T): T;
    match<U>(handlers: {
        some: (value: T) => U;
        none: () => U;
    }): U;
    filter(_predicate: (value: T) => boolean): Option<T>;
    tap(_fn: (value: T) => void): Option<T>;
    zip<U>(_other: Option<U>): Option<[T, U]>;
    toJSON(): {
        tag: 'None';
    };
    toString(): string;
}
/**
 * Create an Option containing a value.
 */
export declare function Some<T>(value: T): Option<T>;
/**
 * Create an empty Option.
 */
export declare function None<T = never>(): Option<T>;
export declare const OptionUtils: {
    /**
     * Create an Option from a nullable value.
     * null | undefined → None, everything else → Some.
     *
     * @example
     * ```ts
     * Option.from(null)      // None
     * Option.from(undefined) // None
     * Option.from(42)        // Some(42)
     * Option.from('')        // Some('')  (empty string is still Some)
     * ```
     */
    from<T>(value: T | null | undefined): Option<T>;
    /**
     * Create an Option from a predicate check.
     */
    fromPredicate<T>(value: T, predicate: (v: T) => boolean): Option<T>;
    /**
     * Check if a value is an Option.
     */
    isOption<T>(value: unknown): value is Option<T>;
    /**
     * Collect an array of Options into an Option of array.
     * Returns None if any Option is None.
     */
    all<T>(options: Option<T>[]): Option<T[]>;
};
export {};
//# sourceMappingURL=option.d.ts.map