import { Failure, Result, Success } from "./result.js";
/**
 * Discriminated union representing a value that may or may not be present.
 *
 * @template T Type of the contained value
 */
export type Maybe<T> = Result<T, void>;
/**
 * Represents a present value.
 */
export type Some<T> = Success<T>;
/**
 * Represents an absent value.
 */
export type None = Failure<void>;
/**
 * Creates a Some instance containing a value.
 *
 * @example
 * const maybeNumber = Some(42);  // Maybe<number>
 */
export declare const Some: <T>(value: T) => Maybe<T>;
/**
 * Singleton instance representing absence of a value.
 *
 * @example
 * const maybeEmpty = None;  // Maybe<never>
 */
export declare const None: Maybe<never>;
export declare namespace Maybe {
    /**
     * Type guard for instances of Some.
     */
    const isSome: <T>(m: Maybe<T>) => m is Some<T>;
    /**
     * Type guard for instances of None.
     */
    const isNone: <T>(m: Maybe<T>) => m is None;
    /**
     * Type guard that checks if a value is a valid Maybe.
     *
     * @param value Unknown value to check
     * @returns true if the value is either Some or None
     */
    const is: (value: unknown) => value is Maybe<unknown>;
    /**
     * Transforms the value inside a Some, leaving None unchanged.
     *
     * @example
     * const numMaybe = Some(42);
     * const strMaybe = Maybe.map(numMaybe, n => n.toString()); // Some("42")
     */
    const map: <T, U>(m: Maybe<T>, fn: (v: T) => U) => Maybe<U>;
    /**
     * Chains Maybe-producing operations.
     *
     * @example
     * const maybeLength = Maybe.flatMap(Some("hello"), s => Some(s.length)); // Some(5)
     */
    const flatMap: <T, U>(m: Maybe<T>, fn: (v: T) => Maybe<U>) => Maybe<U>;
    /**
     * Converts a nullable value to a Maybe.
     *
     * @returns Some(value) if not null/undefined, otherwise None.
     *
     * @example
     * const maybeName: Maybe<string> = Maybe.fromNullable(getNameThatMightReturnNull());
     */
    const fromNullable: <T>(value: T | null | undefined) => Maybe<NonNullable<T>>;
    /**
     * Converts a function's return value to a Maybe.
     * - Returns the existing Maybe if the function returns one
     * - Converts null/undefined returns to None
     * - Wraps other returns in Some
     *
     * @param fn Function to execute
     * @returns Maybe-wrapped result
     *
     * @example
     * const maybeData: Maybe<unknown> = Maybe.from(() => JSON.parse(localStorage.data));
     */
    const from: <T>(fn: () => T) => Maybe<T extends Success<infer Ok> ? Ok : T extends Failure<any> ? never : T>;
    const orElse: <T>(m: Maybe<T>, or: () => T) => T;
}